#include "STcgXRViewport.h"
#include "TcgXRViewportClient.h"
#include "PreviewScene.h"
#include "Editor.h"
#include "LevelEditor.h"
#include "Engine/World.h"
#include "Engine/Level.h"
#include "GameFramework/Actor.h"
#include "CineCameraActor.h"
#include "CineCameraComponent.h"
#include "LevelEditorViewport.h" // FLevelEditorViewportClient
#include "TcgXR.h"

// 构造函数，初始化自定义Viewport
void STcgXRViewport::Construct(const FArguments& InArgs)
{
    SEditorViewport::Construct(SEditorViewport::FArguments());
}

// 创建自定义ViewportClient
TSharedRef<FEditorViewportClient> STcgXRViewport::MakeEditorViewportClient()
{
    if (!PreviewScene.IsValid())
    {
        PreviewScene = MakeUnique<FPreviewScene>(FPreviewScene::ConstructionValues());
    }

    ViewportClient = MakeShared<FTcgXRViewportClient>(PreviewScene.Get(), StaticCastSharedRef<SEditorViewport>(SharedThis(this)));
    ViewportClient->SetViewMode(VMI_Lit);

    // 从第一个主编辑器视口复制相机参数
    if (GEditor)
    {
        for (FEditorViewportClient* VC : GEditor->GetAllViewportClients())
        {
            if (VC && VC->IsPerspective())
            {
                const FVector Loc = VC->GetViewLocation();
                const FRotator Rot = VC->GetViewRotation();
                const bool bIsOrtho = VC->IsOrtho();
                const float FOV = VC->ViewFOV; // 使用源视口FOV
                const float OrthoWidth = 2048.f; // 默认正交宽度
                ViewportClient->SetCameraFrom(Loc, Rot, FOV, OrthoWidth, bIsOrtho);
                break;
            }
        }
    }

    // 应用缓存参数（如果UI在Client创建前触发了设置，不会崩溃）
    ApplyCachedParams();

    return ViewportClient.ToSharedRef();
}

void STcgXRViewport::ApplyCachedParams()
{
    if (!ViewportClient.IsValid()) return;
    if (CachedFOV.IsSet()) { ViewportClient->SetFOV(CachedFOV.GetValue()); CachedFOV.Reset(); }
    if (CachedExposure.IsSet()) { ViewportClient->SetExposure(CachedExposure.GetValue()); CachedExposure.Reset(); }
    if (CachedFocalLength.IsSet()) { ViewportClient->SetFocalLength(CachedFocalLength.GetValue()); CachedFocalLength.Reset(); }
    if (CachedAperture.IsSet()) { ViewportClient->SetAperture(CachedAperture.GetValue()); CachedAperture.Reset(); }
    if (CachedFocusDistance.IsSet()) { ViewportClient->SetFocusDistance(CachedFocusDistance.GetValue()); CachedFocusDistance.Reset(); }
}

// XR状态控制接口
void STcgXRViewport::SetShowKeyed(bool b) { if (ViewportClient) ViewportClient->SetShowKeyed(b); }
void STcgXRViewport::SetVirtualCamMove(bool b) { if (ViewportClient) ViewportClient->SetVirtualCamMove(b); }
void STcgXRViewport::SetMixedRealityBlend(bool b) { if (ViewportClient) ViewportClient->SetMixedRealityBlend(b); }

bool STcgXRViewport::IsShowKeyed() const { return ViewportClient ? ViewportClient->IsShowKeyed() : false; }
bool STcgXRViewport::IsVirtualCamMove() const { return ViewportClient ? ViewportClient->IsVirtualCamMove() : false; }
bool STcgXRViewport::IsMixedRealityBlend() const { return ViewportClient ? ViewportClient->IsMixedRealityBlend() : true; }

// 工具：获取当前锁定的电影相机（如果任何一个关卡视口处于Pilot/锁定状态）
static UCineCameraComponent* GetLockedCineCamera()
{
    if (!GEditor) return nullptr;
    const TArray<FLevelEditorViewportClient*>& Clients = GEditor->GetLevelViewportClients();
    for (FLevelEditorViewportClient* LVC : Clients)
    {
        if (!LVC || !LVC->IsPerspective()) continue;
        AActor* LockedActor = nullptr;
        if (AActor* CineLock = LVC->GetCinematicActorLock().GetLockedActor())
        {
            LockedActor = CineLock;
        }
        else if (LVC->GetActiveActorLock().IsValid())
        {
            LockedActor = LVC->GetActiveActorLock().Get();
        }
        if (LockedActor)
        {
            if (ACineCameraActor* Cine = Cast<ACineCameraActor>(LockedActor))
            {
                return Cine->GetCineCameraComponent();
            }
        }
    }
    return nullptr;
}

// 捕获键盘输入并分发给模块做相机切换
FReply STcgXRViewport::OnKeyDown(const FGeometry& MyGeometry, const FKeyEvent& InKeyEvent)
{
    if (FTcgXRModule* Mod = FModuleManager::GetModulePtr<FTcgXRModule>("TcgXR"))
    {
        if (Mod->HandleKeyDown(InKeyEvent.GetKey()))
        {
            return FReply::Handled();
        }
    }
    return SEditorViewport::OnKeyDown(MyGeometry, InKeyEvent);
}

// 安全设置接口（优先修改锁定到关卡视口的相机，否则本地缓存/ViewportClient）
void STcgXRViewport::SetFOVParam(float InFOV)
{
    if (UCineCameraComponent* CineComp = GetLockedCineCamera())
    {
        CineComp->SetFieldOfView(InFOV);
        return;
    }
    if (ViewportClient.IsValid()) { ViewportClient->SetFOV(InFOV); }
    else { CachedFOV = InFOV; }
}

void STcgXRViewport::SetExposureParam(float InExposure)
{
    if (UCineCameraComponent* CineComp = GetLockedCineCamera())
    {
        FPostProcessSettings& PPS = CineComp->PostProcessSettings;
        PPS.bOverride_AutoExposureBias = true;
        PPS.AutoExposureBias = InExposure;
        CineComp->PostProcessBlendWeight = 1.0f;
        CineComp->MarkRenderStateDirty();
        return;
    }
    if (ViewportClient.IsValid()) { ViewportClient->SetExposure(InExposure); }
    else { CachedExposure = InExposure; }
}

void STcgXRViewport::SetFocalLengthParam(float InFocal)
{
    if (UCineCameraComponent* CineComp = GetLockedCineCamera())
    {
        CineComp->SetCurrentFocalLength(InFocal);
        return;
    }
    if (ViewportClient.IsValid()) { ViewportClient->SetFocalLength(InFocal); }
    else { CachedFocalLength = InFocal; }
}

void STcgXRViewport::SetApertureParam(float InAperture)
{
    if (UCineCameraComponent* CineComp = GetLockedCineCamera())
    {
        CineComp->SetCurrentAperture(InAperture);
        return;
    }
    if (ViewportClient.IsValid()) { ViewportClient->SetAperture(InAperture); }
    else { CachedAperture = InAperture; }
}

void STcgXRViewport::SetFocusDistanceParam(float InFocus)
{
    if (UCineCameraComponent* CineComp = GetLockedCineCamera())
    {
        CineComp->FocusSettings.ManualFocusDistance = InFocus;
        CineComp->SetFocusSettings(CineComp->FocusSettings);
        return;
    }
    if (ViewportClient.IsValid()) { ViewportClient->SetFocusDistance(InFocus); }
    else { CachedFocusDistance = InFocus; }
}

// Copyright Epic Games, Inc. All Rights Reserved.
// 本文件为TcgXR插件主模块，负责插件的初始化、UI布局和命令注册。

#include "TcgXR.h"
#include "TcgXRStyle.h"
#include "TcgXRCommands.h"
#include "ToolMenus.h"
#include "Framework/Docking/TabManager.h"
#include "Widgets/Docking/SDockTab.h"
#include "Widgets/Layout/SBorder.h"
#include "Widgets/SBoxPanel.h"
#include "Widgets/Input/SCheckBox.h"
#include "Widgets/Input/SButton.h"
#include "Widgets/Input/SComboBox.h"
#include "Widgets/Input/SSlider.h"
#include "Widgets/Input/SSpinBox.h"
#include "Widgets/Input/SComboButton.h"
#include "Widgets/Text/STextBlock.h"
#include "Widgets/SWindow.h"
#include "Framework/Application/SlateApplication.h"
#include "STcgXRViewport.h"
#include "TcgXRViewportClient.h"
#include "LevelEditor.h"
#include "LevelEditorViewport.h"
#include "SLevelViewport.h"
#include "EngineUtils.h"
#include "Camera/CameraActor.h"
#include "Editor.h" // FEditorDelegates

static const FName TcgXRTabName("TcgXRWindow");

#define LOCTEXT_NAMESPACE "FTcgXRModule"

void FTcgXRModule::StartupModule()
{
	FTcgXRStyle::Initialize();
	FTcgXRStyle::ReloadTextures();

	FTcgXRCommands::Register();
	
	PluginCommands = MakeShareable(new FUICommandList);
	PluginCommands->MapAction(
		FTcgXRCommands::Get().PluginAction,
		FExecuteAction::CreateRaw(this, &FTcgXRModule::PluginButtonClicked),
		FCanExecuteAction());

	FGlobalTabmanager::Get()->RegisterNomadTabSpawner(TcgXRTabName,
		FOnSpawnTab::CreateRaw(this, &FTcgXRModule::OnSpawnPluginTab))
		.SetDisplayName(LOCTEXT("TcgXRTabTitle", "TcgXR"))
		.SetMenuType(ETabSpawnerMenuType::Hidden);

	UToolMenus::RegisterStartupCallback(FSimpleMulticastDelegate::FDelegate::CreateRaw(this, &FTcgXRModule::RegisterMenus));

	if (GEngine)
	{
		ActorAddedHandle = GEngine->OnLevelActorAdded().AddLambda([this](AActor* /*Actor*/){ RefreshCameraList(); });
		ActorDeletedHandle = GEngine->OnLevelActorDeleted().AddLambda([this](AActor* /*Actor*/){ RefreshCameraList(); });
	}
	// 当编辑器相机移动或切换锁定时，刷新“当前控制”文本
	FEditorDelegates::OnEditorCameraMoved.AddLambda([this](const FVector&, const FRotator&, ELevelViewportType, int32){ RebuildCameraHotkeyUI(); });
}

void FTcgXRModule::ShutdownModule()
{
	UToolMenus::UnRegisterStartupCallback(this);
	UToolMenus::UnregisterOwner(this);

	FGlobalTabmanager::Get()->UnregisterNomadTabSpawner(TcgXRTabName);

	if (GEngine)
	{
		GEngine->OnLevelActorAdded().Remove(ActorAddedHandle);
		GEngine->OnLevelActorDeleted().Remove(ActorDeletedHandle);
	}

	FTcgXRStyle::Shutdown();
	FTcgXRCommands::Unregister();
}

void FTcgXRModule::PluginButtonClicked()
{
	FGlobalTabmanager::Get()->TryInvokeTab(TcgXRTabName);
}

void FTcgXRModule::RegisterMenus()
{
	FToolMenuOwnerScoped OwnerScoped(this);

	if (UToolMenu* Menu = UToolMenus::Get()->ExtendMenu("LevelEditor.MainMenu.Window"))
	{
		FToolMenuSection& Section = Menu->FindOrAddSection("WindowLayout");
		Section.AddMenuEntryWithCommandList(FTcgXRCommands::Get().PluginAction, PluginCommands);
	}

	if (UToolMenu* ToolbarMenu = UToolMenus::Get()->ExtendMenu("LevelEditor.LevelEditorToolBar.PlayToolBar"))
	{
		FToolMenuSection& Section = ToolbarMenu->FindOrAddSection("PluginTools");
		FToolMenuEntry& Entry = Section.AddEntry(FToolMenuEntry::InitToolBarButton(FTcgXRCommands::Get().PluginAction));
		Entry.SetCommandList(PluginCommands);
		Entry.Icon = FSlateIcon(FTcgXRStyle::GetStyleSetName(), TEXT("TcgXR.PluginAction.Small"), TEXT("TcgXR.PluginAction"));
	}
}

bool FTcgXRModule::HandleKeyDown(const FKey& Key)
{
	if (TWeakObjectPtr<ACameraActor>* Found = CameraHotkeyMap.Find(Key))
	{
		SwitchToCamera(*Found);
		RebuildCameraHotkeyUI();
		return true;
	}
	return false;
}

void FTcgXRModule::BindCameraHotkey(TWeakObjectPtr<ACameraActor> Camera, const FKey& Key)
{
	// 确保一个相机只绑定一个键：先移除旧绑定
	TArray<FKey> KeysToRemove;
	for (const auto& Pair : CameraHotkeyMap)
	{
		if (Pair.Value == Camera)
		{
			KeysToRemove.Add(Pair.Key);
		}
	}
	for (const FKey& OldKey : KeysToRemove)
	{
		CameraHotkeyMap.Remove(OldKey);
	}
	// 同一按键重新绑定到新相机
	CameraHotkeyMap.Add(Key, Camera);
	RebuildCameraHotkeyUI();
}

void FTcgXRModule::SwitchToCamera(TWeakObjectPtr<ACameraActor> Camera)
{
	if (!Camera.IsValid()) return;
	FLevelEditorModule& LevelEditorModule = FModuleManager::LoadModuleChecked<FLevelEditorModule>("LevelEditor");
	TSharedPtr<SLevelViewport> ActiveViewport = LevelEditorModule.GetFirstActiveLevelViewport();
	if (!ActiveViewport.IsValid()) return;

	FLevelEditorViewportClient& LVC = ActiveViewport->GetLevelViewportClient();
	LVC.SetActorLock(Camera.Get());
	LVC.UpdateViewForLockedActor();
	if (!ActiveViewport->IsLockedCameraViewEnabled())
	{
		ActiveViewport->ToggleActorPilotCameraView();
	}
	LVC.Invalidate();
}

FText FTcgXRModule::GetCurrentControlledCameraText() const
{
	if (!GEditor) return LOCTEXT("NoEditor", "当前控制: 无（未找到编辑器）");
	const TArray<FLevelEditorViewportClient*>& Clients = GEditor->GetLevelViewportClients();
	for (FLevelEditorViewportClient* LVC : Clients)
	{
		if (!LVC || !LVC->IsPerspective()) continue;
		if (AActor* CineLock = LVC->GetCinematicActorLock().GetLockedActor())
		{
			return FText::Format(LOCTEXT("ControllingCam","当前控制: {0}"), FText::FromString(CineLock->GetActorLabel()));
		}
		if (LVC->GetActiveActorLock().IsValid())
		{
			AActor* Locked = LVC->GetActiveActorLock().Get();
			return FText::Format(LOCTEXT("ControllingActor","当前控制: {0}"), FText::FromString(Locked->GetActorLabel()));
		}
	}
	return LOCTEXT("NoCam","当前控制: 无（未锁定相机）");
}

FText FTcgXRModule::GetBoundKeyTextForCamera(TWeakObjectPtr<ACameraActor> Camera) const
{
	for (const auto& Pair : CameraHotkeyMap)
	{
		if (Pair.Value == Camera)
		{
			return FText::Format(LOCTEXT("BoundKeyFmt","已绑定: {0}"), Pair.Key.GetDisplayName());
		}
	}
	return LOCTEXT("NoKeyBound","未绑定");
}

void FTcgXRModule::RefreshCameraList()
{
	CachedCameras.Reset();
	if (GEditor)
	{
		UWorld* World = GEditor->GetEditorWorldContext().World();
		if (World)
		{
			for (TActorIterator<ACameraActor> It(World); It; ++It)
			{
				CachedCameras.Add(*It);
			}
		}
	}
	RebuildCameraHotkeyUI();
}

void FTcgXRModule::RebuildCameraHotkeyUI()
{
	TSharedPtr<SVerticalBox> Panel = CameraListPanel.Pin();
	if (!Panel.IsValid()) return;
	Panel->ClearChildren();

	// 顶部显示当前控制的相机
	Panel->AddSlot().AutoHeight().Padding(0,2)
	[
		SNew(STextBlock)
		.Text_Lambda([this](){ return GetCurrentControlledCameraText(); })
	];

	int32 Index = 1;
	for (TWeakObjectPtr<ACameraActor> Cam : CachedCameras)
	{
		TWeakObjectPtr<ACameraActor> LocalCam = Cam;
		FText Label = FText::FromString(FString::Printf(TEXT("相机%d: %s"), Index, LocalCam.IsValid() ? *LocalCam->GetActorLabel() : TEXT("(无)")));
		Panel->AddSlot().AutoHeight().Padding(0,2)
		[
			SNew(SHorizontalBox)
			+ SHorizontalBox::Slot().AutoWidth().Padding(2)
			[
				SNew(STextBlock).Text(Label)
			]
			+ SHorizontalBox::Slot().AutoWidth().Padding(8,2)
			[
				SNew(STextBlock)
				.Text_Lambda([this, LocalCam](){ return GetBoundKeyTextForCamera(LocalCam); })
			]
			+ SHorizontalBox::Slot().AutoWidth().Padding(2)
			[
				SNew(SComboButton)
				.ButtonContent()[ SNew(STextBlock).Text(LOCTEXT("BindKey", "绑定按键")) ]
				.OnGetMenuContent_Lambda([this, LocalCam]()
				{
					FMenuBuilder MenuBuilder(true, nullptr);
					TArray<FKey> Keys; Keys.Reserve(9);
					Keys.Add(EKeys::One); Keys.Add(EKeys::Two); Keys.Add(EKeys::Three); Keys.Add(EKeys::Four);
					Keys.Add(EKeys::Five); Keys.Add(EKeys::Six); Keys.Add(EKeys::Seven); Keys.Add(EKeys::Eight); Keys.Add(EKeys::Nine);
					for (const FKey& K : Keys)
					{
						FText KeyName = K.GetDisplayName();
						MenuBuilder.AddMenuEntry(KeyName, LOCTEXT("BindKeyTip","绑定到该键"), FSlateIcon(), FUIAction(FExecuteAction::CreateLambda([this, LocalCam, K](){ BindCameraHotkey(LocalCam, K); })));
					}
					return MenuBuilder.MakeWidget();
				})
			]
			+ SHorizontalBox::Slot().AutoWidth().Padding(2)
			[
				SNew(SButton)
				.Text(LOCTEXT("SwitchNow","切换到该相机"))
				.OnClicked_Lambda([this, LocalCam]()
				{
					SwitchToCamera(LocalCam);
					RebuildCameraHotkeyUI();
					return FReply::Handled();
				})
			]
		];
		++Index;
	}
}

void FTcgXRModule::CloseAllFullscreenWindows()
{
	for (TWeakPtr<SWindow>& W : FullscreenWindows)
	{
		if (TSharedPtr<SWindow> SW = W.Pin())
		{
			SW->RequestDestroyWindow();
		}
	}
	FullscreenWindows.Reset();
}

// 生成主窗口Tab，包括Viewport、右侧摄影机控制面板、底部全屏按钮
TSharedRef<SDockTab> FTcgXRModule::OnSpawnPluginTab(const FSpawnTabArgs& Args)
{
	TSharedPtr<STcgXRViewport> ViewportWidget;

	static float ManualExposure = 0.0f;
	static float ManualFOV = 90.0f;
	static float ManualFocal = 35.0f;
	static float ManualAperture = 2.8f;
	static float ManualFocus = 1000.0f;
	static bool bUseLiveLink = false;
	static TArray<TSharedPtr<FString>> ResolutionOptions;
	ResolutionOptions.Reset();
	ResolutionOptions.Add(MakeShared<FString>(TEXT("1920x1080")));
	ResolutionOptions.Add(MakeShared<FString>(TEXT("2560x1440")));
	ResolutionOptions.Add(MakeShared<FString>(TEXT("3840x2160")));
	static TArray<TSharedPtr<FString>> MonitorOptions;
	static int32 SelectedMonitorIndex = 0;
	static TSharedPtr<FString> SelectedResolution = ResolutionOptions.Num() > 0 ? ResolutionOptions[0] : nullptr;

	MonitorOptions.Reset();
	{
		FDisplayMetrics Metrics;
		FSlateApplication::Get().GetDisplayMetrics(Metrics);
		MonitorOptions.Add(MakeShared<FString>(FString::Printf(TEXT("主显示器 %dx%d"), Metrics.PrimaryDisplayWidth, Metrics.PrimaryDisplayHeight)));
		for (int32 i = 0; i < Metrics.MonitorInfo.Num(); ++i)
		{
			const auto& M = Metrics.MonitorInfo[i];
			FPlatformRect Rect = M.WorkArea;
			MonitorOptions.Add(MakeShared<FString>(FString::Printf(TEXT("显示器%d %dx%d @(%d,%d)"), i, Rect.Right-Rect.Left, Rect.Bottom-Rect.Top, Rect.Left, Rect.Top)));
		}
		if (MonitorOptions.Num() == 0)
		{
			MonitorOptions.Add(MakeShared<FString>(TEXT("显示器0")));
		}
	}

	TSharedRef<SDockTab> Tab = SNew(SDockTab)
		.TabRole(ETabRole::NomadTab)
		[
			SNew(SHorizontalBox)
			+ SHorizontalBox::Slot().FillWidth(1.f)
			[
				SAssignNew(ViewportWidget, STcgXRViewport)
			]
			+ SHorizontalBox::Slot().AutoWidth().Padding(8.f,0.f)
			[
				SNew(SVerticalBox)
				+ SVerticalBox::Slot().AutoHeight().Padding(0,2)
				[
					SAssignNew(CameraListPanel, SVerticalBox)
				]
				// 顶部快速参数行：移除FOV和曝光
				+ SVerticalBox::Slot().AutoHeight().Padding(0, 2)
				[
					SNew(SHorizontalBox)
					// 焦距
					+ SHorizontalBox::Slot().AutoWidth().Padding(2)
					[
						SNew(STextBlock).Text(LOCTEXT("Focal", "焦距"))
					]
					+ SHorizontalBox::Slot().AutoWidth().Padding(2)
					[
						SNew(SSpinBox<float>).MinValue(1.f).MaxValue(300.f)
						.Value_Lambda([&]{ return ManualFocal; })
						.OnValueChanged_Lambda([&](float V){ ManualFocal = V; if(ViewportWidget.IsValid()) ViewportWidget->SetFocalLengthParam(V); })
					]
					// 光圈
					+ SHorizontalBox::Slot().AutoWidth().Padding(8,2)
					[
						SNew(STextBlock).Text(LOCTEXT("Aperture", "光圈"))
					]
					+ SHorizontalBox::Slot().AutoWidth().Padding(2)
					[
						SNew(SSpinBox<float>).MinValue(0.7f).MaxValue(32.f)
						.Value_Lambda([&]{ return ManualAperture; })
						.OnValueChanged_Lambda([&](float V){ ManualAperture = V; if(ViewportWidget.IsValid()) ViewportWidget->SetApertureParam(V); })
					]
					// 对焦
					+ SHorizontalBox::Slot().AutoWidth().Padding(8,2)
					[
						SNew(STextBlock).Text(LOCTEXT("Focus", "对焦"))
					]
					+ SHorizontalBox::Slot().AutoWidth().Padding(2)
					[
						SNew(SSpinBox<float>).MinValue(1.f).MaxValue(100000.f)
						.Value_Lambda([&]{ return ManualFocus; })
						.OnValueChanged_Lambda([&](float V){ ManualFocus = V; if(ViewportWidget.IsValid()) ViewportWidget->SetFocusDistanceParam(V); })
					]
				]

				+ SVerticalBox::Slot().AutoHeight().Padding(0,6,0,0)
				[
					SNew(SHorizontalBox)
					+ SHorizontalBox::Slot().AutoWidth().Padding(2.f)
					[
						SNew(SCheckBox)
						.IsChecked_Lambda([] { return bUseLiveLink ? ECheckBoxState::Checked : ECheckBoxState::Unchecked; })
						.OnCheckStateChanged_Lambda([](ECheckBoxState State) { bUseLiveLink = (State == ECheckBoxState::Checked); })
					]
					+ SHorizontalBox::Slot().AutoWidth().Padding(2.f)
					[
						SNew(STextBlock).Text(LOCTEXT("LiveLinkSwitch", "使用LiveLink外部相机"))
					]
				]

				+ SVerticalBox::Slot().AutoHeight().Padding(0, 8, 0, 0)
				[
					SNew(SVerticalBox)
					.Visibility_Lambda([] { return bUseLiveLink ? EVisibility::Visible : EVisibility::Collapsed; })
					+ SVerticalBox::Slot().AutoHeight()
					[
						SNew(STextBlock).Text(LOCTEXT("LiveLinkTitle", "LiveLink外部相机参数"))
					]
					+ SVerticalBox::Slot().AutoHeight().Padding(0, 2)
					[
						SNew(STextBlock).Text(LOCTEXT("LiveLinkStatus", "状态: 未连接/已连接"))
					]
				]

				+ SVerticalBox::Slot().AutoHeight().VAlign(VAlign_Bottom).Padding(0, 16, 0, 0)
				[
					SNew(SVerticalBox)
					+ SVerticalBox::Slot().AutoHeight().Padding(0, 8, 0, 0)
					[
						SNew(SHorizontalBox)
						+ SHorizontalBox::Slot().AutoWidth().Padding(2.f)
						[
							SNew(STextBlock).Text(LOCTEXT("MonitorLabel", "屏幕"))
						]
						+ SHorizontalBox::Slot().AutoWidth().Padding(2.f)
						[
							SNew(SComboBox<TSharedPtr<FString>>)
							.OptionsSource(&MonitorOptions)
							.OnSelectionChanged_Lambda([&](TSharedPtr<FString> NewItem, ESelectInfo::Type){ SelectedMonitorIndex = FMath::Clamp(MonitorOptions.IndexOfByKey(NewItem), 0, MonitorOptions.Num()-1); })
							.OnGenerateWidget_Lambda([](TSharedPtr<FString> InItem){ return SNew(STextBlock).Text(FText::FromString(*InItem)); })
							[
								SNew(STextBlock).Text_Lambda([&]{ return MonitorOptions.IsValidIndex(SelectedMonitorIndex) ? FText::FromString(*MonitorOptions[SelectedMonitorIndex]) : LOCTEXT("MonitorUnknown","未知屏幕"); })
							]
						]
					]
					+ SVerticalBox::Slot().AutoHeight().Padding(0, 4, 0, 0)
					[
						SNew(SHorizontalBox)
						+ SHorizontalBox::Slot().AutoWidth().Padding(2.f)
						[
							SNew(STextBlock).Text(LOCTEXT("ResolutionLabel", "输出分辨率"))
						]
						+ SHorizontalBox::Slot().AutoWidth().Padding(2.f)
						[
							SNew(SComboBox<TSharedPtr<FString>>)
							.OptionsSource(&ResolutionOptions)
							.OnSelectionChanged_Lambda([&](TSharedPtr<FString> NewItem, ESelectInfo::Type) { SelectedResolution = NewItem; })
							.OnGenerateWidget_Lambda([](TSharedPtr<FString> InItem) { return SNew(STextBlock).Text(FText::FromString(*InItem)); })
							[
								SNew(STextBlock).Text_Lambda([&] { return SelectedResolution.IsValid() ? FText::FromString(*SelectedResolution) : LOCTEXT("ResUnknown","未知"); })
							]
						]
					]
					+ SVerticalBox::Slot().AutoHeight().Padding(0, 6, 0, 0)
					[
						SNew(SHorizontalBox)
						+ SHorizontalBox::Slot().AutoWidth().Padding(2)
						[
							SNew(SButton)
							.Text(LOCTEXT("FullscreenBtn", "全屏显示"))
							.OnClicked_Lambda([this, ViewportWidget]() {
								if(!ViewportWidget.IsValid()) return FReply::Handled();
								TSharedPtr<FString> LocalSelectedResolution = SelectedResolution;
								int32 LocalSelectedMonitorIndex = SelectedMonitorIndex;
								int32 W=1920, H=1080;
								{
									FString Res= LocalSelectedResolution.IsValid() ? *LocalSelectedResolution : FString(TEXT("1920x1080"));
									FString LW, LH;
									if(Res.Split(TEXT("x"), &LW, &LH)) { W = FCString::Atoi(*LW); H = FCString::Atoi(*LH); }
								}
								TSharedPtr<SWindow> FullscreenWindow = SNew(SWindow)
									.Title(LOCTEXT("XRFullscreen", "XR全屏输出"))
									.ClientSize(FVector2D(W, H))
									.SizingRule(ESizingRule::FixedSize)
									.SupportsMaximize(false)
									.SupportsMinimize(false)
									.HasCloseButton(true)
									.UseOSWindowBorder(false)
									.CreateTitleBar(false);

								TSharedPtr<STcgXRViewport> FSViewport;
								FullscreenWindow->SetContent(SAssignNew(FSViewport, STcgXRViewport));

								if (FSlateApplication::IsInitialized())
								{
									FSlateApplication::Get().AddWindow(FullscreenWindow.ToSharedRef());
									FDisplayMetrics Metrics; FSlateApplication::Get().GetDisplayMetrics(Metrics);
									FVector2D TargetPos(0,0);
									if (Metrics.MonitorInfo.IsValidIndex(LocalSelectedMonitorIndex))
									{
										const auto& M = Metrics.MonitorInfo[LocalSelectedMonitorIndex];
										TargetPos = FVector2D(M.WorkArea.Left, M.WorkArea.Top);
									}
									FullscreenWindow->MoveWindowTo(TargetPos);
								}

								FullscreenWindows.Add(FullscreenWindow);

								if (ViewportWidget->GetClient().IsValid() && FSViewport.IsValid())
								{
									auto Src = ViewportWidget->GetClient();
									auto Dst = FSViewport->GetClient();
									Dst->SetCameraFrom(Src->GetViewLocation(), Src->GetViewRotation(), Src->GetFOV(), 2048.f, false);
									Dst->SetFOV(Src->GetFOV());
									Dst->SetExposure(Src->GetExposure());
									Dst->SetFocalLength(Src->GetFocalLength());
									Dst->SetAperture(Src->GetAperture());
									Dst->SetFocusDistance(Src->GetFocusDistance());
								}

								return FReply::Handled();
							})
						]
						+ SHorizontalBox::Slot().AutoWidth().Padding(2)
						[
							SNew(SButton)
							.Text(LOCTEXT("CloseFullscreenBtn", "关闭所有全屏"))
							.OnClicked_Lambda([this]()
							{
								CloseAllFullscreenWindows();
								return FReply::Handled();
							})
						]
					]
				]
			]
		];

	RefreshCameraList();
	return Tab;
}

#undef LOCTEXT_NAMESPACE

IMPLEMENT_MODULE(FTcgXRModule, TcgXR)

// Copyright Epic Games, Inc. All Rights Reserved.

#include "TcgXRCommands.h"

#define LOCTEXT_NAMESPACE "FTcgXRModule"

void FTcgXRCommands::RegisterCommands()
{
	UI_COMMAND(PluginAction, "TcgXR", "Execute TcgXR action", EUserInterfaceActionType::Button, FInputChord());
}

#undef LOCTEXT_NAMESPACE

// Copyright Epic Games, Inc. All Rights Reserved.

#include "TcgXRStyle.h"
#include "TcgXR.h"
#include "Framework/Application/SlateApplication.h"
#include "Styling/SlateStyleRegistry.h"
#include "Slate/SlateGameResources.h"
#include "Interfaces/IPluginManager.h"
#include "Styling/SlateStyleMacros.h"

#define RootToContentDir Style->RootToContentDir

TSharedPtr<FSlateStyleSet> FTcgXRStyle::StyleInstance = nullptr;

void FTcgXRStyle::Initialize()
{
	if (!StyleInstance.IsValid())
	{
		StyleInstance = Create();
		FSlateStyleRegistry::RegisterSlateStyle(*StyleInstance);
	}
}

void FTcgXRStyle::Shutdown()
{
	FSlateStyleRegistry::UnRegisterSlateStyle(*StyleInstance);
	ensure(StyleInstance.IsUnique());
	StyleInstance.Reset();
}

FName FTcgXRStyle::GetStyleSetName()
{
	static FName StyleSetName(TEXT("TcgXRStyle"));
	return StyleSetName;
}


const FVector2D Icon16x16(16.0f, 16.0f);
const FVector2D Icon20x20(20.0f, 20.0f);
const FVector2D Icon40x40(40.0f, 40.0f);

TSharedRef< FSlateStyleSet > FTcgXRStyle::Create()
{
	TSharedRef< FSlateStyleSet > Style = MakeShareable(new FSlateStyleSet("TcgXRStyle"));
	Style->SetContentRoot(IPluginManager::Get().FindPlugin("TcgXR")->GetBaseDir() / TEXT("Resources"));

	// Use vector image brushes from Resources/TcgXR.svg for toolbar/menu icons
	Style->Set("TcgXR.PluginAction", new IMAGE_BRUSH_SVG(TEXT("TcgXR"), Icon40x40));
	Style->Set("TcgXR.PluginAction.Small", new IMAGE_BRUSH_SVG(TEXT("TcgXR"), Icon20x20));
	return Style;
}

void FTcgXRStyle::ReloadTextures()
{
	if (FSlateApplication::IsInitialized())
	{
		FSlateApplication::Get().GetRenderer()->ReloadTextureResources();
	}
}

const ISlateStyle& FTcgXRStyle::Get()
{
	return *StyleInstance;
}

// FTcgXRViewportClient implementation has been moved inline to TcgXRViewportClient.h
// This translation unit is intentionally left empty to avoid duplicate definitions.