file
function     int32 SAvaLevelViewportScreenGrid::OnPaint

				{
					DrawGrid(InPaintArgs, InAllottedGeometry, InMyCullingRect, OutDrawElements, InLayerId,
						AvaViewportSettings->GridSize, AvaViewportSettings->GridColor, AvaViewportSettings->GridThickness);
				}
			}
		}
	}

	return InLayerId;

file
function     void SAvaEaseCurveEditor::Construct

	bGridSnap = InArgs._GridSnap;
	GridSize = InArgs._GridSize;
	GridColor = InArgs._GridColor;
	ExtendedGridColor = InArgs._ExtendedGridColor;
	CurveThickness = InArgs._CurveThickness;
	CurveColor = InArgs._CurveColor;
	Operation = InArgs._Operation;

	StartText = InArgs._StartText;

file
function     int32 SAvaEaseCurveEditor::PaintGrid

			FSlateDrawElement::MakeLines(OutDrawElements, NormalizedLayerId
				, InAllottedGeometry.ToPaintGeometry(), LinePoints, InDrawEffects, GridColor, false);
		}

		// Horizontal grid lines
		for (float Y = 0.f; Y < 1.f; Y += GridStep)
		{
			const float ScreenY = InScaleInfo.OutputToLocalY(Y);

file
function     int32 SAvaEaseCurveEditor::PaintGrid

			FSlateDrawElement::MakeLines(OutDrawElements, NormalizedLayerId
				, InAllottedGeometry.ToPaintGeometry(), LinePoints, InDrawEffects, GridColor, false);
		}
	}

	return NormalizedLayerId;
}

file
class        class SAvaEaseCurveEditor : public SCompoundWidget, public FGCObject, public FEditorUndoClient

	TAttribute<bool> bGridSnap;
	TAttribute<int32> GridSize;
	FLinearColor GridColor;
	FLinearColor ExtendedGridColor;
	float CurveThickness = 1.f;
	FLinearColor CurveColor;
	TAttribute<FAvaEaseCurveTool::EOperation> Operation;

	TAttribute<FText> StartText;

file
function     UAvaViewportSettings::UAvaViewportSettings

	bGridAlwaysVisible = false;
	GridSize = 50;
	GridColor = FLinearColor(0.6, 0.0, 0.0, 0.4);
	GridThickness = 1.f;

	bPixelGridEnabled = true;
	PixelGridColor = FLinearColor(0.5, 0.5, 0.5, 0.4);

	SnapState = static_cast<int32>(EAvaViewportSnapState::Global | EAvaViewportSnapState::Screen | EAvaViewportSnapState::Grid);

file
class        class UAvaViewportSettings : public UDeveloperSettings

	UPROPERTY(Config, EditAnywhere, BlueprintReadWrite, Category = "Screen Grid")
	FLinearColor GridColor;

	UPROPERTY(Config, EditAnywhere, BlueprintReadWrite, Category = "Screen Grid", Meta = (UIMin = 1, UIMax = 8, ClampMin = 1, ClampMax = 8))
	float GridThickness;

	UPROPERTY(Config, EditAnywhere, BlueprintReadWrite, Category = "Pixel Grid")
	bool bPixelGridEnabled;

file
function     void UFractureToolPlaneCut::Render
lambda-function

			const int32 NumGridLines = 20;
			const float GridLineSpacing = PlaneSize / (NumGridLines - 1);
			const FColor GridColor(64, 64, 64, 128);
			const float GridThickness = 1.0f;
			const UE::Geometry::FFrame3d DrawFrame(Center, Transform.GetRotation());
			MeshDebugDraw::DrawSimpleGrid(DrawFrame, NumGridLines, GridLineSpacing, GridThickness, GridColor, true, PDI, FTransform::Identity);
		};

		if (GizmoSettings->IsGizmoEnabled())
		{
			const FTransform& Transform = GizmoSettings->GetTransform();
			EnumerateVisualizationMapping(PlanesMappings, RenderCuttingPlanesTransforms.Num(), [&](int32 Idx, FVector ExplodedVector)

file
function     void UDynamicMeshSculptTool::Render

	{
		FPrimitiveDrawInterface* PDI = RenderAPI->GetPrimitiveDrawInterface();
		FColor GridColor(128, 128, 128, 32);
		float GridThickness = 0.5f*RenderCameraState.GetPDIScalingFactor();
		int NumGridLines = 10;
		FFrame3d DrawFrame(GizmoProperties->Position, GizmoProperties->Rotation);
		MeshDebugDraw::DrawSimpleFixedScreenAreaGrid(RenderCameraState, DrawFrame, NumGridLines, 45.0, GridThickness, GridColor, false, PDI, FTransform::Identity);
	}
}

void UDynamicMeshSculptTool::OnTick(float DeltaTime)
{
	TRACE_CPUPROFILER_EVENT_SCOPE(DynamicMeshSculptTool_OnTick);

file
function     void UMeshSculptToolBase::Render

	{
		FPrimitiveDrawInterface* PDI = RenderAPI->GetPrimitiveDrawInterface();
		FColor GridColor(128, 128, 128, 32);
		float GridThickness = 0.5f*RenderCameraState.GetPDIScalingFactor();
		int NumGridLines = 10;
		FFrame3d DrawFrame(GizmoProperties->Position, GizmoProperties->Rotation);
		MeshDebugDraw::DrawSimpleFixedScreenAreaGrid(RenderCameraState, DrawFrame, NumGridLines, 45.0, GridThickness, GridColor, false, PDI, FTransform::Identity);
	}
}

	CurveEditor = SNew(SCurveEditor)
		.ShowCurveSelector(true)
		.GridColor(FLinearColor(1.0f, 0.8f, 0.8f))
		.ViewMinInput(-0.01f)
		.ViewMaxInput(1.01f)
		.ViewMinOutput(-0.01f)
		.ViewMaxOutput(1.01f)
		.TimelineLength(1.01f)
		.HideUI(false)

file
function     FSampledSequenceValueGridOverlayStyle::FSampledSequenceValueGridOverlayStyle

FSampledSequenceValueGridOverlayStyle::FSampledSequenceValueGridOverlayStyle()
	: GridColor(FLinearColor::Black)
	, GridThickness(1.f)
	, LabelTextColor(FLinearColor::White)
	, LabelTextFont(FAppStyle::GetFontStyle("Regular"))
	, DesiredWidth(AudioWidgetStylesSharedParams::DefaultWidth)
	, DesiredHeight(AudioWidgetStylesSharedParams::DefaultHeight)
{

file
function     void SAudioSpectrumPlot::Construct

	FrequencyAxisPixelBucketMode = InArgs._FrequencyAxisPixelBucketMode;
	BackgroundColor = InArgs._BackgroundColor;
	GridColor = InArgs._GridColor;
	AxisLabelColor = InArgs._AxisLabelColor;
	SpectrumColor = InArgs._SpectrumColor;
	bAllowContextMenu = InArgs._AllowContextMenu;
	OnContextMenuOpening = InArgs._OnContextMenuOpening;
	OnGetAudioSpectrumData = InArgs._OnGetAudioSpectrumData;
}

file
function     FLinearColor SAudioSpectrumPlot::GetGridColor

FLinearColor SAudioSpectrumPlot::GetGridColor(const FWidgetStyle& InWidgetStyle) const
{
	const FSlateColor& SlateColor = (GridColor.Get() != FSlateColor::UseStyle()) ? GridColor.Get() : Style->GridColor;
	return SlateColor.GetColor(InWidgetStyle) * InWidgetStyle.GetColorAndOpacityTint();
}

FLinearColor SAudioSpectrumPlot::GetAxisLabelColor(const FWidgetStyle& InWidgetStyle) const
{
	const FSlateColor& SlateColor = (AxisLabelColor.Get() != FSlateColor::UseStyle()) ? AxisLabelColor.Get() : Style->AxisLabelColor;

file
function     void SSampledSequenceValueGridOverlay::Construct

	bHideLabels = InArgs._HideLabels;
	bHideGrid = InArgs._HideGrid;
	GridColor = InArgs._Style->GridColor;
	LabelTextFont = InArgs._Style->LabelTextFont;
	LabelTextColor = InArgs._Style->LabelTextColor;
	DesiredWidth = InArgs._Style->DesiredWidth;
	DesiredHeight = InArgs._Style->DesiredHeight;
	GridThickness = InArgs._Style->GridThickness;
}

file
function     int32 SSampledSequenceValueGridOverlay::OnPaint

					LinePoints,
					ESlateDrawEffect::None,
					GridColor.GetSpecifiedColor(),
					false,
					GridThickness
				);
			}
		}
	}

file
function     void SSampledSequenceValueGridOverlay::OnStyleUpdated

void SSampledSequenceValueGridOverlay::OnStyleUpdated(const FSampledSequenceValueGridOverlayStyle UpdatedStyle)
{
	GridColor = UpdatedStyle.GridColor;
	LabelTextFont = UpdatedStyle.LabelTextFont;
	LabelTextColor = UpdatedStyle.LabelTextColor;
	DesiredWidth = UpdatedStyle.DesiredWidth;
	DesiredHeight = UpdatedStyle.DesiredHeight;
	GridThickness = UpdatedStyle.GridThickness;

	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Appearance)
	FSlateColor GridColor = FMath::Lerp(FStyleColors::Background.GetSpecifiedColor(), FStyleColors::Foreground.GetSpecifiedColor(), 0.1f);
	FAudioSpectrumPlotStyle& SetGridColor(const FSlateColor& InGridColor) { GridColor = InGridColor; return *this; }

	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Appearance)
	FSlateColor AxisLabelColor = FStyleColors::Foreground;
	FAudioSpectrumPlotStyle& SetAxisLabelColor(const FSlateColor& InAxisLabelColor) { AxisLabelColor = InAxisLabelColor; return *this; }

	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Appearance)

	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Appearance)
	FSlateColor GridColor;
	FSampledSequenceValueGridOverlayStyle& SetGridColor(const FSlateColor InGridColor) { GridColor = InGridColor; return *this; }

	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Appearance)
	float GridThickness;
	FSampledSequenceValueGridOverlayStyle& SetGridThickness(const float InGridThickness) { GridThickness = InGridThickness; return *this; }

	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Appearance)

file
class        class SAudioSpectrumPlot : public SCompoundWidget

	TAttribute<EAudioSpectrumPlotFrequencyAxisPixelBucketMode> FrequencyAxisPixelBucketMode;
	TAttribute<FSlateColor> BackgroundColor;
	TAttribute<FSlateColor> GridColor;
	TAttribute<FSlateColor> AxisLabelColor;
	TAttribute<FSlateColor> SpectrumColor;
	TAttribute<bool> bAllowContextMenu;
	FOnContextMenuOpening OnContextMenuOpening;
	FGetAudioSpectrumData OnGetAudioSpectrumData;
};

file
class        class SSampledSequenceValueGridOverlay : public SLeafWidget

	const FSampledSequenceValueGridOverlayStyle* Style = nullptr;

	FSlateColor GridColor;
	FSlateColor LabelTextColor;
	FSlateFontInfo LabelTextFont;
	float DesiredWidth;
	float DesiredHeight;
	float GridThickness;

file
function     void MeshDebugDraw::DrawHierarchicalGrid

		// Select our color, using the last grid color over again if we don't have enough.
		FColor GridColor = Colors.Num() - 1 > Level ? Colors[Level] : Colors.Last();

		// Finally draw one grid level.
		MeshDebugDraw::DrawSimpleGrid(GridFrame, GridLines, GridScales[Level], AdjustedLineWidth,
			GridColor, bDepthTested, PDI, Transform);
	}	

}

file
function     void UConstructionPlaneMechanic::Render

		const int32 NumGridLines = Settings->NumGridLines;
		const float GridThickness = 0.75f * PDIScale;
		constexpr FColor GridColor(128, 128, 128, 32);
		static constexpr bool bDepthTested = false;
		FPrimitiveDrawInterface* PDI = RenderAPI->GetPrimitiveDrawInterface();
		const FTransform DrawTransform = FTransform::Identity;

		switch (Settings->GridMode)
		{

file
function     void UConstructionPlaneMechanic::Render

		{
			const double GridSpacing = Settings->GridSpacing;
			MeshDebugDraw::DrawSimpleGrid(DrawFrame, NumGridLines, GridSpacing, GridThickness, GridColor, bDepthTested, PDI, DrawTransform);
			break;
		}
			
		case EModelingComponentsPlaneVisualizationMode::HierarchicalGrid:
		{
			const double ZoomFactor = Distance(CameraState.Position, DrawFrame.Origin);

file
function     void UConstructionPlaneMechanic::Render

			TArray<FColor> Colors;
			Colors.Add(GridColor);
				
			const double Scale = Settings->GridScale;
			constexpr int32 MaxLevelDensity = 500;
			constexpr int32 Subdivision = 5;
				
			MeshDebugDraw::DrawHierarchicalGrid(Scale, ZoomFactor / Scale, MaxLevelDensity, WorldMaxBounds, WorldMinBounds, Levels, Subdivision, Colors, DrawFrame, GridThickness, bDepthTested, PDI, DrawTransform);

file
function     void UConstructionPlaneMechanic::Render

		{
			const double VisualAngleSpan = Settings->GridSize * 90.;
			MeshDebugDraw::DrawSimpleFixedScreenAreaGrid(CameraState, DrawFrame, NumGridLines, VisualAngleSpan, GridThickness, GridColor, bDepthTested, PDI, DrawTransform);
			break;
		}
		}
	}
}

file
function     void SNPSimFrameView::DrawHorizontalAxisGrid

		const float ViewHeight = Viewport.GetHeight();

		const FLinearColor GridColor(0.0f, 0.0f, 0.0f, 0.1f);
		//const FLinearColor TextBgColor(0.05f, 0.05f, 0.05f, 1.0f);
		//const FLinearColor TextColor(1.0f, 1.0f, 1.0f, 1.0f);
		const FLinearColor TopTextColor(1.0f, 1.0f, 1.0f, 0.7f);

		//const TSharedRef<FSlateFontMeasure> FontMeasureService = FSlateApplication::Get().GetRenderer()->GetFontMeasureService();

file
function     void SNPSimFrameView::DrawHorizontalAxisGrid

			// Draw vertical grid line.
			DrawContext.DrawBox(X, 0, 1, ViewHeight, Brush, GridColor);

			const FString Text = FText::AsNumber(Index).ToString();
			//const FVector2D TextSize = FontMeasureService->Measure(Text, Font);
			//constexpr float TextH = 14.0f;

			// Draw background for index text.

file
function     int32 SDataGraph::OnPaint

	// Data provider is needed for time line markers.

	static const FLinearColor GridColor = FLinearColor(0.0f,0.0f,0.0f, 0.25f);
	static const FLinearColor GridTextColor = FLinearColor(1.0f,1.0f,1.0f, 0.25f);
	TArray<FVector2D> LinePoints;
	const float LabelSize = MaxFontCharHeight * 7.0f;

	const TSharedPtr<FTrackedStat> FirstTrackedStat = GetFirstGraph();
	if( FirstTrackedStat.IsValid() )

file
function     int32 SDataGraph::OnPaint

					LinePoints,
					DrawEffects,
					GridColor
				);
				LinePoints.Empty();

				// Don't draw label if too close to the time values.
				if( MarkerPosX < LabelSize || MarkerPosX > AreaX1-LabelSize )
				{

file
function     int32 SDataGraph::OnPaint

					LinePoints,
					DrawEffects,
					GridColor
				);
				LinePoints.Empty();

				// Don't draw label if too close to the time values.
				if( MarkerPosX < LabelSize || MarkerPosX > AreaX1-LabelSize )
				{

file
function     int32 SDataGraph::OnPaint

			LinePoints,
			DrawEffects,
			BasicHintColor ? *BasicHintColor : GridColor
		);
		LinePoints.Empty();

		float HintOffsetY = 2.0f/*-MaxFontCharHeight * 0.5f*/;
		if( IndicatorIndex == FirstHintIndex )
		{

file
function     int32 SHistogram::OnPaint

	uint32 CountX = (uint32)((AllottedGeometry.Size.X-LabelBuffer*2.0f) / (float)Description.GetBinCount());
	float StartX = LabelBuffer;
	static const FLinearColor GridColor = FLinearColor(0.0f,0.0f,0.0f, 0.25f);
	static const FLinearColor GridTextColor = FLinearColor(1.0f,1.0f,1.0f, 0.25f);
	static const FLinearColor BorderColor = FLinearColor(0.0f,0.0f,0.0f,1.0f);
	FSlateFontInfo SummaryFont = FCoreStyle::GetDefaultFontStyle("Regular", 8);
	const float MaxFontCharHeight = static_cast<float>(FontMeasureService->Measure( TEXT("!"), SummaryFont ).Y);
	TArray<FVector2D> LinePoints;

file
function     int32 SHistogram::OnPaint

			LinePoints,
			DrawEffects,
			GridColor
		);
		LinePoints.Empty();

		// Bottom - X-Axes numbers, starting from MinValue
		const FString XLabel = FString::Printf(TEXT("%.0f"), Description.MinValue + (float)Index * Description.Interval);
		float FontCharWidth = static_cast<float>(FontMeasureService->Measure(XLabel, SummaryFont).X);

file
function     int32 SHistogram::OnPaint

			LinePoints,
			DrawEffects,
			GridColor
			);
		LinePoints.Empty();

		// Bottom - Y-Axes numbers, starting from 0
		const FString YLabel = FString::Printf(TEXT("%i"), Description.Normalize ? 25 * (4-Index) : Description.GetTotalCount() / 4 * Index);
		float FontCharWidth = static_cast<float>(FontMeasureService->Measure(YLabel, SummaryFont).X);

file
function     void FMemoryGraphTrack::DrawVerticalAxisGrid

		Params.Precision = Precision;

		const FLinearColor GridColor(0.0f, 0.0f, 0.0f, 0.1f);

		for (double Value = StartValue; Value < TopValue; Value += Grid)
		{
			const float Y = Y0 + RoundedViewHeight - FMath::RoundToFloat(ViewportY.GetOffsetForValue(Value));

			const float LabelY = FMath::Min(MaxLabelY, FMath::Max(MinLabelY, Y - TextH / 2));

file
function     void FMemoryGraphTrack::DrawVerticalAxisGrid

			// Draw horizontal grid line.
			DrawContext.DrawBox(0, Y, ViewWidth, 1, Brush, GridColor);

			// Draw label.
			Params.Y = LabelY;
			Params.Value = Value;
			DrawHorizontalAxisLabel(Params);
		}

file
function     void SPacketView::DrawVerticalAxisGrid

		const float ViewWidth = Viewport.GetWidth();

		const FLinearColor GridColor(0.0f, 0.0f, 0.0f, 0.1f);
		const FLinearColor TextBgColor(0.05f, 0.05f, 0.05f, 1.0f);
		const FLinearColor TextColor(1.0f, 1.0f, 1.0f, 1.0f);

		const TSharedRef<FSlateFontMeasure> FontMeasureService = FSlateApplication::Get().GetRenderer()->GetFontMeasureService();
		const float FontScale = DrawContext.Geometry.Scale;

file
function     void SPacketView::DrawVerticalAxisGrid

			// Draw horizontal grid line.
			DrawContext.DrawBox(0, Y, ViewWidth, 1, Brush, GridColor);

			const int64 ValueBits = static_cast<int64>(Value);
			const FString Text = (ValueBits == 0) ? TEXT("0") : FString::Format(TEXT("{0} bits"), { FText::AsNumber(ValueBits).ToString() });
			const FVector2D TextSize = FontMeasureService->Measure(Text, Font, FontScale) / FontScale;
			const float TextW = static_cast<float>(TextSize.X);
			constexpr float TextH = 14.0f;

file
function     void SPacketView::DrawHorizontalAxisGrid

		const float ViewHeight = Viewport.GetHeight();

		const FLinearColor GridColor(0.0f, 0.0f, 0.0f, 0.1f);
		//const FLinearColor TextBgColor(0.05f, 0.05f, 0.05f, 1.0f);
		//const FLinearColor TextColor(1.0f, 1.0f, 1.0f, 1.0f);
		const FLinearColor TopTextColor(1.0f, 1.0f, 1.0f, 0.7f);

		//const TSharedRef<FSlateFontMeasure> FontMeasureService = FSlateApplication::Get().GetRenderer()->GetFontMeasureService();
		//const float FontScale = DrawContext.Geometry.Scale;

file
function     void SPacketView::DrawHorizontalAxisGrid

			// Draw vertical grid line.
			DrawContext.DrawBox(X, 0, 1, ViewHeight, Brush, GridColor);

			const FString Text = FText::AsNumber(Index).ToString();
			//const FVector2D TextSize = FontMeasureService->Measure(Text, Font, FontScale) / FontScale;
			//constexpr float TextH = 14.0f;

			// Draw background for index text.

file
function     void FTimingGraphTrack::DrawVerticalAxisGrid

		const double StartValue = FMath::GridSnap(BottomValue, Grid);

		const FLinearColor GridColor(0.0f, 0.0f, 0.0f, 0.1f);
		const FLinearColor TextBgColor(0.05f, 0.05f, 0.05f, 1.0f);
		const FLinearColor TextColor = FirstTimeUnitSeries->GetColor().CopyWithNewOpacity(1.0f);

		for (double Value = StartValue; Value < TopValue; Value += Grid)
		{
			const float Y = Y0 + RoundedViewHeight - FMath::RoundToFloat(ViewportY.GetOffsetForValue(Value));

file
function     void FTimingGraphTrack::DrawVerticalAxisGrid

			// Draw horizontal grid line.
			DrawContext.DrawBox(0, Y, ViewWidth, 1, Brush, GridColor);

			const FVector2D LabelTextSize = FontMeasureService->Measure(LabelText, Font, FontScale) / FontScale;
			const float LabelX = X0 - static_cast<float>(LabelTextSize.X) - 4.0f;
			const float LabelY = FMath::Min(Y0 + GetHeight() - TextH, FMath::Max(Y0, Y - TextH / 2));

			// Draw background for value text.

file
function     void SFrameTrack::DrawVerticalAxisGrid

	const float RoundedViewHeight = FMath::RoundToFloat(ViewportY.GetSize());

	const FLinearColor GridColor(0.0f, 0.0f, 0.0f, 0.1f);
	const FLinearColor TextBgColor(0.05f, 0.05f, 0.05f, 1.0f);

	const TSharedRef<FSlateFontMeasure> FontMeasureService = FSlateApplication::Get().GetRenderer()->GetFontMeasureService();
	const float FontScale = DrawContext.Geometry.Scale;

	// Available axis, pre-ordered by value.

file
function     void SFrameTrack::DrawVerticalAxisGrid

		// Draw horizontal grid line.
		DrawContext.DrawBox(0, Axis.Y, ViewWidth, 1.0f, Brush, GridColor);

		const FString LabelText = (Axis.Value == 0.0) ? TEXT("0") :
								  (Axis.Value <= 1.0) ? FString::Printf(TEXT("%s (%.0f fps)"), *TimeUtils::FormatTimeAuto(Axis.Value), 1.0 / Axis.Value) :
														TimeUtils::FormatTimeAuto(Axis.Value);

		const float LabelTextWidth = static_cast<float>(FontMeasureService->Measure(LabelText, Font, FontScale).X / FontScale);

file
function     void SFrameTrack::DrawHorizontalAxisGrid

			// Draw vertical grid lines.
			const FLinearColor GridColor(0.0f, 0.0f, 0.0f, 0.1f);
			for (int32 Index = StartIndex; Index < RightIndex; Index += Grid)
			{
				const float X = FMath::RoundToFloat(ViewportX.GetOffsetForValue(Index));
				DrawContext.DrawBox(X, 0.0f, 1.0f, ViewHeight, Brush, GridColor);
			}
			DrawContext.LayerId++;
		}
		else
		{
			const TSharedRef<FSlateFontMeasure> FontMeasureService = FSlateApplication::Get().GetRenderer()->GetFontMeasureService();

file
function     FCurveEditorViewportClient::FCurveEditorViewportClient

	LabelColor = SharedData->EditorOptions->LabelColor;
	SelectedLabelColor = SharedData->EditorOptions->SelectedLabelColor;
	GridColor = SharedData->EditorOptions->GridColor;
	GridTextColor = SharedData->EditorOptions->GridTextColor;
	LabelBlockBkgColor = SharedData->EditorOptions->LabelBlockBkgColor;
	SelectedKeyColor = SharedData->EditorOptions->SelectedKeyColor;

	MouseOverCurveIndex = INDEX_NONE;
	MouseOverSubIndex = INDEX_NONE;

file
function     void FCurveEditorViewportClient::DrawGrid

	while(InNum * InGridSpacing < SharedData->EndIn)
	{
		FLinearColor LineColor = GridColor;

		// Change line color for important frames.
		if (bSnapToFrames)
		{
			LineColor = NormalLine;
			if (InNum % FrameStep == 0)

file
function     void FCurveEditorViewportClient::DrawGrid

	{
		FIntPoint GridPos = CalcScreenPos(FVector2D(0.f, OutNum*OutGridSpacing));
		LineItem.SetColor( GridColor );
		LineItem.Draw( Canvas, FVector2D(LabelWidth, GridPos.Y), FVector2D(LabelWidth + CurveViewX, GridPos.Y) );
		OutNum++;
	}

	// Calculate screen position of graph origin and draw white lines to indicate it

file
class        class FCurveEditorViewportClient : public FCommonViewportClient

	FLinearColor LabelColor;
	FLinearColor SelectedLabelColor;
	FLinearColor GridColor;
	FLinearColor GridTextColor;
	FLinearColor LabelBlockBkgColor;
	FLinearColor SelectedKeyColor;

	int32 MouseOverCurveIndex;
	int32 MouseOverSubIndex;

file
class        class UCurveEdOptions : public UObject

	UPROPERTY(EditAnywhere, config, Category=Options)
	FLinearColor GridColor;

	UPROPERTY(EditAnywhere, config, Category=Options)
	FLinearColor GridTextColor;

	UPROPERTY(EditAnywhere, config, Category=Options)
	FLinearColor LabelBlockBkgColor;

file
function     void SCurveEditor::Construct

	DesiredSize = InArgs._DesiredSize;

	GridColor = InArgs._GridColor;

	bIsUsingSlider = false;
	bAllowAutoFrame = true;

	// if editor size is set, use it, otherwise, use default value
	if (DesiredSize.Get().IsZero())

file
function     void SCurveEditor::PaintGridLines

						LinePoints,
						DrawEffects,
						GridColor,
						false);

					//Show grid time
					if (bDrawInputGridNumbers)
					{
						FString TimeStr = FString::Printf(TEXT("%.2f"), Time);

file
function     void SCurveEditor::PaintGridLines

						LinePoints,
						DrawEffects,
						GridColor,
						false);

					//Show grid value
					if (bDrawOutputGridNumbers)
					{
						FString ValueStr = FString::Printf(TEXT("%.2f"), Value);

file
class        class SCurveEditor : public SCompoundWidget, public FGCObject, public FEditorUndoClient

	/** The color used to draw the grid lines. */
	FLinearColor GridColor;

	/** The tolerance to use when reducing curves */
	float ReduceTolerance;

	/** Generic Popup Entry */
	TWeakPtr<IMenu> EntryPopupMenu;

file
function     void UViewportWorldInteraction::RefreshTransformGizmo

			// Animate the grid a little bit
			const FLinearColor GridColor = FLinearColor::LerpUsingHSV(
				FLinearColor::White,
				FLinearColor::Yellow,
				FMath::MakePulsatingValue( GetTimeSinceEntered().GetTotalSeconds(), 0.5f ) ).CopyWithNewOpacity( GridAlpha );

			const float GridInterval = GEditor->GetGridSize();

file
function     void UViewportWorldInteraction::RefreshTransformGizmo

				static FName GridColorParameterName( "GridColor" );
				LocalSnapGridMID->SetVectorParameterValue( GridColorParameterName, GridColor );

				static FName GridCenterParameterName( "GridCenter" );
				LocalSnapGridMID->SetVectorParameterValue( GridCenterParameterName, SnapGridCenter );

				static FName GridIntervalParameterName( "GridInterval" );
				LocalSnapGridMID->SetScalarParameterValue( GridIntervalParameterName, GridInterval );

file
function     FWorldGridPreviewer::FWorldGridPreviewer

	: CellSize(0)
	, LoadingRange(0)
	, GridColor(ForceInit)
	, GridOffset(ForceInit)
	, World(nullptr)
{}

FWorldGridPreviewer::FWorldGridPreviewer(UWorld* InWorld, bool bInIs2D)
	: FWorldGridPreviewer()

file
function     void FWorldGridPreviewer::Update

		MaterialInstance->SetScalarParameterValueEditorOnly(TEXT("Grid_CellSize"), (float)CellSize);
		MaterialInstance->SetScalarParameterValueEditorOnly(TEXT("Grid_LoadingRange"), (float)LoadingRange);
		MaterialInstance->SetVectorParameterValueEditorOnly(TEXT("Grid_Color"), GridColor);
		//MaterialInstance->SetVectorParameterValueEditorOnly(TEXT("Grid_Offset"), GridOffset);		
	}
}
#endif

file
function     void URuntimePartitionLHGrid::PostEditChangeProperty

	{
		WorldGridPreviewer->CellSize = CellSize;
		WorldGridPreviewer->GridColor = DebugColor;
		WorldGridPreviewer->GridOffset = FVector::ZeroVector;
		WorldGridPreviewer->LoadingRange = LoadingRange;
		WorldGridPreviewer->Update();
	}

	Super::PostEditChangeProperty(InPropertyChangedEvent);

file
function     void FWorldPartitionRuntimeSpatialHashGridPreviewer::Draw

					}

					if (CachedParameters.GridColor != Grid.DebugColor)
					{
						MID->SetVectorParameterValue(*FString::Printf(TEXT("Grid%d_Color"), i), Grid.DebugColor);
						CachedParameters.GridColor = Grid.DebugColor;
					}

					FVector GridOffset = FVector(Grid.Origin, 0) + (bUseAlignedGridLevels ? FVector(0.5 * PreviewCellSize) : FVector::ZeroVector);
					if (CachedParameters.GridOffset != GridOffset)
					{
						MID->SetVectorParameterValue(*FString::Printf(TEXT("Grid%d_Offset"), i), GridOffset);

file
function     void AWorldSettings::PostEditChangeProperty

		{
			InstancedFoliageGridGridPreviewer->CellSize = InstancedFoliageGridSize;
			InstancedFoliageGridGridPreviewer->GridColor = FColor::White;
			InstancedFoliageGridGridPreviewer->GridOffset = FVector::ZeroVector;
			InstancedFoliageGridGridPreviewer->LoadingRange = MAX_int32;
			InstancedFoliageGridGridPreviewer->Update();
		}
	}

	int32 CellSize;
	int32 LoadingRange;
	FLinearColor GridColor;
	FVector GridOffset;

private:
	TObjectPtr<UWorld> World;
	TObjectPtr<UMaterial> Material;
	TObjectPtr<UMaterialInstanceConstant> MaterialInstance;

file
function     FGridParametersCache

			, CellSize(0)
			, LoadingRange(0.f)
			, GridColor(0.f, 0.f, 0.f, 0.f)
			, GridOffset(FVector::ZeroVector)
		{}

		bool bEnabled;
		int32 CellSize;
		float LoadingRange;
		FLinearColor GridColor;
		FVector GridOffset;
	};

	enum { MAX_PREVIEW_GRIDS = 4 };
	FGridParametersCache GridParameters[MAX_PREVIEW_GRIDS];
#endif