定义游戏的 UWP 应用框架
注意
本主题是使用 DirectX 创建简单的通用 Windows 平台 (UWP) 游戏教程系列的一部分。 此链接上的主题设置了该系列的上下文。
对通用 Windows 平台 (UWP) 游戏进行编码的第一步是构建框架，使应用对象可以与 Windows 交互，包括 Windows 运行时功能（如暂停-恢复事件处理、窗口可见性的更改以及贴靠）。
目标
- 为通用 Windows 平台 (UWP) DirectX 游戏设置框架，以及实现定义整个游戏流的状态机。
注意
若要继续本主题，请查看下载的 Simple3DGameDX 示例游戏的源代码。
简介
在设置游戏项目主题中，我们介绍了 wWinMain 函数以及 IFrameworkViewSource 和 IFrameworkView 接口。 我们已了解到 App 类（可以看到是在 Simple3DGameDX 项目的 App.cpp 源代码文件中进行定义）同时充当视图提供程序工厂和视图提供程序。
本主题从这里开始，更加详细地介绍了游戏中的 App 类应如何实现 IFrameworkView 方法。
App::Initialize 方法
在应用程序启动时，Windows 调用的第一种方法是 IFrameworkView::Initialize 的实现。
你的实现应处理 UWP 游戏的最基本行为，例如确保游戏可以通过订阅事件来处理暂停（稍后可以恢复）事件。 我们还可以在此处访问显示适配器设备，因此，我们可以创建依赖于设备的图形资源。
void Initialize(CoreApplicationView const& applicationView)
{
applicationView.Activated({ this, &App::OnActivated });
CoreApplication::Suspending({ this, &App::OnSuspending });
CoreApplication::Resuming({ this, &App::OnResuming });
// At this point we have access to the device.
// We can create the device-dependent resources.
m_deviceResources = std::make_shared<DX::DeviceResources>();
}
尽可能避免使用原始指针（几乎总是可以）。
- 对于 Windows 运行时类型，通常可以完全避免指针，而只在堆栈上构造值。 如果确实需要指针，请使用 winrt::com_ptr（我们很快会看到该指针的示例）。
- 对于唯一指针，请使用 std::unique_ptr 和 std::make_unique。
- 对于共享指针，请使用 std::shared_ptr 和 std::make_shared。
App::SetWindow 方法
执行 Initialize 后，Windows 会调用 IFrameworkView::SetWindow 的实现，传递表示游戏主窗口的 CoreWindow 对象。
在 App::SetWindow 中，我们订阅与窗口相关的事件，并配置一些窗口和显示行为。 例如，我们构造了鼠标指针（通过 CoreCursor 类），它可由鼠标和触摸控件使用。 我们还将窗口对象传递给与设备相关的资源对象。
我们将在游戏流管理主题中详细讨论事件处理。
void SetWindow(CoreWindow const& window)
{
//CoreWindow window = CoreWindow::GetForCurrentThread();
window.Activate();
window.PointerCursor(CoreCursor(CoreCursorType::Arrow, 0));
PointerVisualizationSettings visualizationSettings{ PointerVisualizationSettings::GetForCurrentView() };
visualizationSettings.IsContactFeedbackEnabled(false);
visualizationSettings.IsBarrelButtonFeedbackEnabled(false);
m_deviceResources->SetWindow(window);
window.Activated({ this, &App::OnWindowActivationChanged });
window.SizeChanged({ this, &App::OnWindowSizeChanged });
window.Closed({ this, &App::OnWindowClosed });
window.VisibilityChanged({ this, &App::OnVisibilityChanged });
DisplayInformation currentDisplayInformation{ DisplayInformation::GetForCurrentView() };
currentDisplayInformation.DpiChanged({ this, &App::OnDpiChanged });
currentDisplayInformation.OrientationChanged({ this, &App::OnOrientationChanged });
currentDisplayInformation.StereoEnabledChanged({ this, &App::OnStereoEnabledChanged });
DisplayInformation::DisplayContentsInvalidated({ this, &App::OnDisplayContentsInvalidated });
}
App::Load 方法
现在设置了主窗口，会调用 IFrameworkView::Load 的实现。 与 SetWindow 或 Initialize 相比，Load 是预取游戏数据或资源的更好位置。
void Load(winrt::hstring const& /* entryPoint */)
{
if (!m_main)
{
m_main = winrt::make_self<GameMain>(m_deviceResources);
}
}
如你所见，实际工作会委托给我们在此处创建的 GameMain 对象的构造函数。 GameMain 类在 GameMain.h 和 GameMain.cpp 中定义。
GameMain::GameMain 构造函数
GameMain 构造函数（以及它调用的其他成员函数）会开始一组异步加载操作，以创建游戏对象、加载图形资源并初始化游戏的状态机。 我们还会在游戏开始之前做一些必要的准备，如设置任意开始状态或全局值。
Windows 对游戏开始处理输入前所能花费的时间施加了限制。 因此使用异步（正如我们在这里所做的那样）意味着 Load 可以快速返回，而它已开始的工作会在后台继续进行。 如果加载时间较长，或者如果有大量资源，则为用户提供经常更新的进度条是一个好主意。
如果你不熟悉异步编程，请参阅使用 C++/WinRT 执行并发和异步操作。
GameMain::GameMain(std::shared_ptr<DX::DeviceResources> const& deviceResources) :
m_deviceResources(deviceResources),
m_windowClosed(false),
m_haveFocus(false),
m_gameInfoOverlayCommand(GameInfoOverlayCommand::None),
m_visible(true),
m_loadingCount(0),
m_updateState(UpdateEngineState::WaitingForResources)
{
m_deviceResources->RegisterDeviceNotify(this);
m_renderer = std::make_shared<GameRenderer>(m_deviceResources);
m_game = std::make_shared<Simple3DGame>();
m_uiControl = m_renderer->GameUIControl();
m_controller = std::make_shared<MoveLookController>(CoreWindow::GetForCurrentThread());
auto bounds = m_deviceResources->GetLogicalSize();
m_controller->SetMoveRect(
XMFLOAT2(0.0f, bounds.Height - GameUIConstants::TouchRectangleSize),
XMFLOAT2(GameUIConstants::TouchRectangleSize, bounds.Height)
);
m_controller->SetFireRect(
XMFLOAT2(bounds.Width - GameUIConstants::TouchRectangleSize, bounds.Height - GameUIConstants::TouchRectangleSize),
XMFLOAT2(bounds.Width, bounds.Height)
);
SetGameInfoOverlay(GameInfoOverlayState::Loading);
m_uiControl->SetAction(GameInfoOverlayCommand::None);
m_uiControl->ShowGameInfoOverlay();
// Asynchronously initialize the game class and load the renderer device resources.
// By doing all this asynchronously, the game gets to its main loop more quickly
// and in parallel all the necessary resources are loaded on other threads.
ConstructInBackground();
}
winrt::fire_and_forget GameMain::ConstructInBackground()
{
auto lifetime = get_strong();
m_game->Initialize(m_controller, m_renderer);
co_await m_renderer->CreateGameDeviceResourcesAsync(m_game);
// The finalize code needs to run in the same thread context
// as the m_renderer object was created because the D3D device context
// can ONLY be accessed on a single thread.
// co_await of an IAsyncAction resumes in the same thread context.
m_renderer->FinalizeCreateGameDeviceResources();
InitializeGameState();
if (m_updateState == UpdateEngineState::WaitingForResources)
{
// In the middle of a game so spin up the async task to load the level.
co_await m_game->LoadLevelAsync();
// The m_game object may need to deal with D3D device context work so
// again the finalize code needs to run in the same thread
// context as the m_renderer object was created because the D3D
// device context can ONLY be accessed on a single thread.
m_game->FinalizeLoadLevel();
m_game->SetCurrentLevelToSavedState();
m_updateState = UpdateEngineState::ResourcesLoaded;
}
else
{
// The game is not in the middle of a level so there aren't any level
// resources to load.
}
// Since Game loading is an async task, the app visual state
// may be too small or not be activated. Put the state machine
// into the correct state to reflect these cases.
if (m_deviceResources->GetLogicalSize().Width < GameUIConstants::MinPlayableWidth)
{
m_updateStateNext = m_updateState;
m_updateState = UpdateEngineState::TooSmall;
m_controller->Active(false);
m_uiControl->HideGameInfoOverlay();
m_uiControl->ShowTooSmall();
m_renderNeeded = true;
}
else if (!m_haveFocus)
{
m_updateStateNext = m_updateState;
m_updateState = UpdateEngineState::Deactivated;
m_controller->Active(false);
m_uiControl->SetAction(GameInfoOverlayCommand::None);
m_renderNeeded = true;
}
}
void GameMain::InitializeGameState()
{
// Set up the initial state machine for handling Game playing state.
...
}
下面概述了构造函数启动的工作序列。
- 创建和初始化 GameRenderer 类型的对象。 有关详细信息，请参阅呈现框架 I：呈现简介。
- 创建和初始化 Simple3DGame 类型的对象。 有关详细信息，请参阅定义主游戏对象。
- 创建游戏 UI 控件对象和显示游戏信息覆盖层以在加载资源文件时显示进度栏。 有关详细信息，请参阅添加用户界面。
- 创建控制器对象，以从控制器（触控装置、鼠标或 Xbox 游戏控制器）读取输入。 有关详细信息，请参阅添加控件。
- 在屏幕的左下角和右下角定义两个矩形区域，分别用于移动和相机触摸控件。 玩家会将左下角的矩形（在 SetMoveRect 调用中定义）用作虚拟控制板来前后左右移动相机。 右下角的矩形（由 SetFireRect 方法定义）可用作设计弹药的虚拟按钮。
- 使用协同例程将资源加载分解为单独的阶段。 对 Direct3D 设备上下文的访问仅限于原先创建设备上下文的线程；而对用于对象创建的 Direct3D 设备的访问无线程限制。 因此，GameRenderer::CreateGameDeviceResourcesAsync 协同例程可以在不同于完成任务 (GameRenderer::FinalizeCreateGameDeviceResources) 的单独线程上运行，而完成任务在原始线程上运行。
- 我们通过 Simple3DGame::LoadLevelAsync 和 Simple3DGame::FinalizeLoadLevel 使用类似的模式来加载级别资源。
我们会在下一个主题（游戏流管理）中详细了解 GameMain::InitializeGameState。
App::OnActivated 方法
接下来，引发 CoreApplicationView::Activated 事件。 因此，会调用你所拥有的任何 OnActivated 事件处理程序（如我们的 App::OnActivated 方法）。
void OnActivated(CoreApplicationView const& /* applicationView */, IActivatedEventArgs const& /* args */)
{
CoreWindow window = CoreWindow::GetForCurrentThread();
window.Activate();
}
我们在此处进行的唯一工作是激活主 CoreWindow。 或者，你可以选择在 App::SetWindow 中执行该操作。
App::Run 方法
Initialize、SetWindow 和 Load 已设置了此阶段。 现在游戏已设置并正在运行，会调用 IFrameworkView::Run 的实现。
void Run()
{
m_main->Run();
}
工作会再次委托给 GameMain。
GameMain::Run 方法
GameMain::Run 是游戏的主循环；可以在 GameMain.cpp 中找到它。 基本逻辑是在游戏窗口保持到打开期间，调度所有事件，更新计时器，然后呈现并展示图形管道的结果。 另外在此处，用于在游戏状态之间转换的事件会进行调度和处理。
此处的代码还涉及游戏引擎状态机中的两个状态。
- UpdateEngineState::Deactivated。 这会指定游戏窗口已停用（失去焦点）或已贴靠。
- UpdateEngineState::TooSmall。 这会指定客户端区域太小，无法在其中呈现游戏。
在这两种状态中的任一状态下，游戏会暂停事件处理，并等待窗口激活、取消贴靠或重设大小。
在游戏窗口可见（Window.Visible 为 true）时，必须处理消息队列中到达的每个事件，因此必须使用 ProcessAllIfPresent 选项调用 CoreWindowDispatch.ProcessEvents。 其他选项可能导致延迟处理消息事件，这会让人感到游戏停止响应，或者导致触摸行为反应慢。
当游戏不可见（Window.Visible 为 false）、暂停或太小（贴靠）时，你不希望应用使用任何资源循环去调度永不会到达的消息。 在这种情况下，游戏必须使用 ProcessOneAndAllPending 选项。 该选项在获得事件前将进行阻止，随后处理该事件（以及处理队列中在处理第一个事件期间到达的任何其他事件）。 CoreWindowDispatch.ProcessEvents 随后将在处理队列之后立即返回。
在下面所示的示例代码中，m_visible 数据成员表示窗口的可见性。 暂停游戏后，其窗口会不可见。 当窗口可见时，m_updateState 的值（UpdateEngineState 枚举）会进一步确定窗口是停用（失去焦点）、太小（贴靠）还是大小正确。
void GameMain::Run()
{
while (!m_windowClosed)
{
if (m_visible)
{
switch (m_updateState)
{
case UpdateEngineState::Deactivated:
case UpdateEngineState::TooSmall:
if (m_updateStateNext == UpdateEngineState::WaitingForResources)
{
WaitingForResourceLoading();
m_renderNeeded = true;
}
else if (m_updateStateNext == UpdateEngineState::ResourcesLoaded)
{
// In the device lost case, we transition to the final waiting state
// and make sure the display is updated.
switch (m_pressResult)
{
case PressResultState::LoadGame:
SetGameInfoOverlay(GameInfoOverlayState::GameStats);
break;
case PressResultState::PlayLevel:
SetGameInfoOverlay(GameInfoOverlayState::LevelStart);
break;
case PressResultState::ContinueLevel:
SetGameInfoOverlay(GameInfoOverlayState::Pause);
break;
}
m_updateStateNext = UpdateEngineState::WaitingForPress;
m_uiControl->ShowGameInfoOverlay();
m_renderNeeded = true;
}
if (!m_renderNeeded)
{
// The App is not currently the active window and not in a transient state so just wait for events.
CoreWindow::GetForCurrentThread().Dispatcher().ProcessEvents(CoreProcessEventsOption::ProcessOneAndAllPending);
break;
}
// otherwise fall through and do normal processing to get the rendering handled.
default:
CoreWindow::GetForCurrentThread().Dispatcher().ProcessEvents(CoreProcessEventsOption::ProcessAllIfPresent);
Update();
m_renderer->Render();
m_deviceResources->Present();
m_renderNeeded = false;
}
}
else
{
CoreWindow::GetForCurrentThread().Dispatcher().ProcessEvents(CoreProcessEventsOption::ProcessOneAndAllPending);
}
}
m_game->OnSuspending(); // Exiting due to window close, so save state.
}
App::Uninitialize 方法
游戏结束时，会调用 IFrameworkView::Uninitialize 的实现。 这使我们有机会执行清理。 关闭游戏窗口不会终止应用的进程，而是将应用单一实例的状态写入内存。 如果在系统回收此内存时必须执行一些特殊操作（包括任何特殊的资源清理），则将执行该清理的代码放入 Uninitialize 中。
在我们的示例中，App::Uninitialize 不执行任何操作。
void Uninitialize()
{
}
提示
在开发自己的游戏时，请围绕本主题中所述的方法设计启动代码。 此处是对各方法的基本建议的简单列表。
- 使用 Initialize 分配主类和连接基本事件处理程序。
- 使用 SetWindow 订阅任何特定于窗口的事件，并将主窗口传递到与设备相关的资源对象，以便在创建交换链时可以使用该窗口。
- 使用 Load 来处理任何其余设置、启动对象的异步创建和加载资源。 如果需要创建任何临时文件或数据，如按顺序生成的资源，也在这里完成。
后续步骤
本主题介绍了使用 DirectX 的 UWP 游戏的一些基本结构。 最好记住这些方法，因为我们将在后面的主题中回顾其中一些方法。
在下一个主题（游戏流管理）中，我们将深入了解如何管理游戏状态和事件处理以便让游戏顺畅进行。
反馈
即将发布：在整个 2024 年，我们将逐步淘汰作为内容反馈机制的“GitHub 问题”，并将其取代为新的反馈系统。 有关详细信息，请参阅：https://aka.ms/ContentUserFeedback。
提交和查看相关反馈