void UGeometryCacheComponent::UpdateTrackSectionMeshData(int32 SectionIndex, FGeometryCacheMeshData* MeshData)
{
	// Check if the index is in range and Vertices contains any data
	check(SectionIndex < TrackSections.Num() && MeshData != nullptr && "Invalid SectionIndex or Mesh Data");
	// Reset this section (in case it already existed)
	FTrackRenderData& UpdateSection = TrackSections[SectionIndex];
	
	// Number of Vertices
	const int32 NumVerts = MeshData->Vertices.Num();
	
	// Update MeshDataPointer
	UpdateSection.MeshData = MeshData;

	//if (SceneProxy)
	//{		
	//	UpdateTrackSectionVertexbuffer(SectionIndex, MeshData);
	//	UpdateTrackSectionIndexbuffer(SectionIndex, MeshData->Indices);
	//	// Will update the bounds (used for frustum culling)
	//	MarkRenderTransformDirty();
	//	MarkRenderDynamicDataDirty();
	//}
	//else
	//{
	//	// Recreate scene proxy
	//	MarkRenderStateDirty(); 
	//}

	// Update overall bounds	
	UpdateLocalBounds();

	MarkRenderStateDirty();
}

void UMeshComponent::SetMaterial(int32 ElementIndex, UMaterialInterface* Material)
{
	if (ElementIndex >= 0)
	{
		if (Materials.IsValidIndex(ElementIndex) && (Materials[ElementIndex] == Material))
		{
			// Do nothing, the material is already set
		}
		else
		{
			// Grow the array if the new index is too large
			if (Materials.Num() <= ElementIndex)
			{
				Materials.AddZeroed(ElementIndex + 1 - Materials.Num());
			}

			// Set the material and invalidate things
			Materials[ElementIndex] = Material;
			MarkRenderStateDirty();

			if (BodyInstance.IsValidBodyInstance())
			{
				BodyInstance.UpdatePhysicalMaterials();
			}
		}
	}
}

bool UPaperTileMapComponent::SetTileMap(class UPaperTileMap* NewTileMap)
{
	if (NewTileMap != TileMap)
	{
		// Don't allow changing the tile map if we are "static".
		AActor* Owner = GetOwner();
		if (!IsRegistered() || (Owner == nullptr) || (Mobility != EComponentMobility::Static))
		{
			TileMap = NewTileMap;

			// Need to send this to render thread at some point
			MarkRenderStateDirty();

			// Update physics representation right away
			RecreatePhysicsState();

			// Since we have new mesh, we need to update bounds
			UpdateBounds();

			return true;
		}
	}

	return false;
}

void UGameplayDebuggingComponent::OnRep_UpdateEQS()
{
#if  USE_EQS_DEBUGGER
    // decode scoring data
    if (World && World->GetNetMode() == NM_Client)
    {
        TArray<uint8> UncompressedBuffer;
        int32 UncompressedSize = 0;
        const int32 HeaderSize = sizeof(int32);
        uint8* SrcBuffer = (uint8*)EQSRepData.GetData();
        FMemory::Memcpy(&UncompressedSize, SrcBuffer, HeaderSize);
        SrcBuffer += HeaderSize;
        const int32 CompressedSize = EQSRepData.Num() - HeaderSize;

        UncompressedBuffer.AddZeroed(UncompressedSize);

        FCompression::UncompressMemory((ECompressionFlags)(COMPRESS_ZLIB), (void*)UncompressedBuffer.GetData(), UncompressedSize, SrcBuffer, CompressedSize);
        FMemoryReader ArReader(UncompressedBuffer);

        ArReader << EQSLocalData;
    }

    UpdateBounds();
    MarkRenderStateDirty();
#endif //USE_EQS_DEBUGGER
}

void FGameplayDebuggerCategory_AI::OnDataPackReplicated(int32 DataPackId)
{
	if (DataPackId == PathDataPackId)
	{
		MarkRenderStateDirty();
	}
}

void ULineBatchComponent::DrawBox(const FBox& Box, const FMatrix& TM, const FColor& Color, uint8 DepthPriorityGroup)
{
	FVector	B[2], P, Q;
	int32 ai, aj;
	B[0] = Box.Min;
	B[1] = Box.Max;

	for( ai=0; ai<2; ai++ ) for( aj=0; aj<2; aj++ )
	{
		P.X=B[ai].X; Q.X=B[ai].X;
		P.Y=B[aj].Y; Q.Y=B[aj].Y;
		P.Z=B[0].Z; Q.Z=B[1].Z;
		new(BatchedLines) FBatchedLine(TM.TransformPosition(P), TM.TransformPosition(Q), Color, DefaultLifeTime, 0.0f, DepthPriorityGroup);

		P.Y=B[ai].Y; Q.Y=B[ai].Y;
		P.Z=B[aj].Z; Q.Z=B[aj].Z;
		P.X=B[0].X; Q.X=B[1].X;
		new(BatchedLines) FBatchedLine(TM.TransformPosition(P), TM.TransformPosition(Q), Color, DefaultLifeTime, 0.0f, DepthPriorityGroup);

		P.Z=B[ai].Z; Q.Z=B[ai].Z;
		P.X=B[aj].X; Q.X=B[aj].X;
		P.Y=B[0].Y; Q.Y=B[1].Y;
		new(BatchedLines) FBatchedLine(TM.TransformPosition(P), TM.TransformPosition(Q), Color, DefaultLifeTime, 0.0f, DepthPriorityGroup);
	}
	// LineBatcher and PersistentLineBatcher components will be updated at the end of UWorld::Tick
	MarkRenderStateDirty();
}

void AViewManager::TurnOnOutlineRendering()
{
	PostProcessVolume->bEnabled = true;
	for (TObjectIterator<AActor> Itr; Itr; ++Itr)
	{
		auto CurrentObject = *Itr;
		bool FoundOutlineObject = false;
		for (auto OutlineObject : PlanElements)
		{
			if (OutlineObject == CurrentObject)
			{
				FoundOutlineObject = true;
			}
		}
		if (!FoundOutlineObject)
		{
			CurrentObject->SetActorHiddenInGame(true);
		}
	}
	for (auto OutlineObject : PlanElements)
	{
		if (OutlineObject)
		{
			OutlineObject->SetActorHiddenInGame(false);
			auto RenderComponent = OutlineObject->GetRootPrimitiveComponent();
			if (RenderComponent)
			{
				RenderComponent->bRenderCustomDepth = true;
				RenderComponent->bRenderInMainPass = false;
				RenderComponent->MarkRenderStateDirty();
			}
		}
	}
}

void ULineBatchComponent::ApplyWorldOffset(const FVector& InOffset, bool bWorldShift)
{
	Super::ApplyWorldOffset(InOffset, bWorldShift);

	bool bDirty = false;
	for (FBatchedLine& Line : BatchedLines)
	{
		Line.Start += InOffset;
		Line.End += InOffset;
		bDirty = true;
	}

	for (FBatchedPoint& Point : BatchedPoints)
	{
		Point.Position += InOffset;
		bDirty = true;
	}

	for (FBatchedMesh& Mesh : BatchedMeshes)
	{
		for (FVector& Vert : Mesh.MeshVerts)
		{
			Vert += InOffset;
			bDirty = true;
		}
	}

	if (bDirty)
	{
		MarkRenderStateDirty();
	}
}

bool UPaperGroupedSpriteComponent::RemoveInstance(int32 InstanceIndex)
{
	if (!PerInstanceSpriteData.IsValidIndex(InstanceIndex))
	{
		return false;
	}

	// Request navigation update
	UNavigationSystem::UpdateNavOctree(this);

	// remove instance
	PerInstanceSpriteData.RemoveAt(InstanceIndex);

	// update the physics state
	if (bPhysicsStateCreated)
	{
		// TODO: it may be possible to instead just update the BodyInstanceIndex for all bodies after the removed instance. 
		ClearAllInstanceBodies();
		CreateAllInstanceBodies();
	}

	// Indicate we need to update render state to reflect changes
	MarkRenderStateDirty();

	return true;
}

void ULineBatchComponent::DrawLines(const TArray<FBatchedLine>& InLines)
{
	BatchedLines.Append(InLines);
	
	// LineBatcher and PersistentLineBatcher components will be updated at the end of UWorld::Tick
	MarkRenderStateDirty();
}

void AViewManager::TurnOffOutlineRendering()
{  
	PostProcessVolume->bEnabled = false;
	for (TObjectIterator<AActor> Itr; Itr; ++Itr)
	{
		auto CurrentObject = *Itr;
		if (CurrentObject)
		{
			CurrentObject->SetActorHiddenInGame(false); 
		}
	}
	for (auto OutlineObject : PlanElements)
	{
		if (OutlineObject)
		{
			OutlineObject->SetActorHiddenInGame(false);
			auto RenderComponent = OutlineObject->GetRootPrimitiveComponent();
			if (RenderComponent)
			{
				RenderComponent->bRenderCustomDepth = false;
				RenderComponent->bRenderInMainPass = true;
				RenderComponent->MarkRenderStateDirty();
			}
		}
	}
	CameraSwitchToStandardPerspective();
}

/** Invalidates the light's cached lighting with the option to recreate the light Guids. */
void ULightComponent::InvalidateLightingCacheInner(bool bRecreateLightGuids)
{
	// Save the light state for transactions.
	Modify();

	// Detach the component from the scene for the duration of this function.
	FComponentReregisterContext ReregisterContext(this);

	// Block until the RT processes the unregister before modifying variables that it may need to access
	FlushRenderingCommands();

	StaticShadowDepthMap.Empty();
	BeginReleaseResource(&StaticShadowDepthMap);

	bPrecomputedLightingIsValid = false;

	if (bRecreateLightGuids)
	{
		// Create new guids for light.
		UpdateLightGUIDs();
	}
	else
	{
		ValidateLightGUIDs();
		ShadowMapChannel = INDEX_NONE;
	}
	
	// Send to render thread
	MarkRenderStateDirty();
}

void ULineBatchComponent::DrawLine(const FVector& Start, const FVector& End, const FLinearColor& Color, uint8 DepthPriority, const float Thickness, const float LifeTime)
{
	new(BatchedLines) FBatchedLine(Start, End, Color, LifeTime, Thickness, DepthPriority);

	// LineBatcher and PersistentLineBatcher components will be updated at the end of UWorld::Tick
	MarkRenderStateDirty();
}

void UExponentialHeightFogComponent::SetDirectionalInscatteringExponent(float Value)
{
	if(DirectionalInscatteringExponent != Value)
	{
		DirectionalInscatteringExponent = Value;
		MarkRenderStateDirty();
	}
}

void ULightComponent::SetMaterial(int32 ElementIndex, UMaterialInterface* InMaterial)
{
	if (ElementIndex == 0)
	{
		LightFunctionMaterial = InMaterial;
		MarkRenderStateDirty();
	}
}

void UBillboardComponent::SetUV(int32 NewU, int32 NewUL, int32 NewV, int32 NewVL)
{
	U = NewU;
	UL = NewUL;
	V = NewV;
	VL = NewVL;
	MarkRenderStateDirty();
}

void USpotLightComponent::SetOuterConeAngle(float NewOuterConeAngle)
{
	if (AreDynamicDataChangesAllowed(false)
		&& NewOuterConeAngle != OuterConeAngle)
	{
		OuterConeAngle = NewOuterConeAngle;
		MarkRenderStateDirty();
	}
}