Windows桌面叠加透明窗口开发指南：从原理到实战实现

如果你是一名游戏玩家、视频剪辑师，或者需要长时间专注屏幕工作的开发者，有没有那么一瞬间，你希望屏幕上的某些元素能“悬浮”在所有窗口之上，并且能自由调节透明度，甚至加上一些个性化的视觉辅助？比如，一个永不消失的游戏准星，一个半透明的待办事项清单，或者一个酷炫的桌面粒子特效。

这听起来像是需要复杂编程才能实现的功能，但今天要介绍的这个开源项目，让你用极简的方式就能拥有这一切。它不是一个单一的软件，而是一个基于Windows 桌面窗口管理器（DWM）和DirectX的轻量级框架，核心目标就是：创建可叠加、可穿透、可自定义渲染的透明桌面窗口。

很多人第一次看到“桌面叠加透明窗口”，会以为它只是个“桌面美化工具”。但它的技术内核远不止于此。它真正解决的，是传统桌面应用窗口层级固定、交互受限的痛点。通过它，你可以：

1. 实现真正的“画中画”：让一个窗口（如计时器、性能监控）始终悬浮在最前端，且不影响你操作背后的任何软件。
2. 创造无干扰的视觉辅助：自定义准星、防眩光遮罩、阅读高亮条，这些辅助工具可以透明地叠加在游戏或工作软件上，提升效率或体验。
3. 打造动态桌面背景：渲染粒子系统、音频可视化等动态效果作为桌面底层，而你的图标和窗口依然可以正常操作。

本文将深入解析这个项目的原理，并提供从环境搭建、核心功能实现到实战案例的完整指南。即使你不是C++专家，也能跟随步骤，打造属于自己的桌面增强工具。

1. 核心价值：为什么你需要关注桌面叠加窗口技术？

在深入代码之前，我们先明确它的应用场景，这比技术细节更重要。

传统窗口的局限：在Windows系统中，普通窗口遵循严格的Z序（Z-order）管理和消息传递机制。一个窗口要么全屏置顶挡住一切，要么被其他窗口覆盖。你想让一个提示框既可见又不影响点击后面的内容？原生API很难优雅地实现。

叠加窗口的突破：

• 始终置顶（Top-most）：窗口位于正常Z序的顶端，不会被其他标准窗口覆盖。
• 点击穿透（Click-through）：窗口虽然可见，但鼠标点击事件会直接传递给下层的窗口，自身不拦截。这是实现“非干扰式悬浮”的关键。
• 透明与半透明：可以通过设置阿尔法通道（Alpha Channel）实现整体透明，或使用每像素透明度实现异形窗口。
• 自定义渲染：窗口的客户区完全由你自己绘制（使用Direct2D、GDI+甚至OpenGL），你可以画任何图形、文字或粒子效果。

适合谁使用？

• 游戏玩家：制作自定义准星、显示实时硬件信息（FPS、温度）、添加防蓝光遮罩。
• 效率工作者：创建悬浮的番茄钟、全局快捷键提示、透明剪贴板历史。
• 开发者/极客：开发桌面小部件（Widget）、系统监控悬浮窗、动态桌面。
• 辅助功能开发者：为视障用户创建屏幕阅读高亮框，为专注需求提供减少干扰的遮罩。

这个项目的意义在于，它封装了实现上述特性的复杂Win32 API和DirectX交互，提供了一个更清晰的起点。

2. 核心概念与原理剖析

要理解这个项目，需要先弄清楚几个关键概念。

2.1 窗口样式（Window Styles）与扩展样式

创建特殊窗口的核心在于正确设置CreateWindowEx函数的参数。

• WS_EX_LAYERED：分层窗口的关键。这是实现透明和半透明的基石。它允许系统将窗口内容先合成到一个离屏位图，再与屏幕合成。
• WS_EX_TRANSPARENT：实现点击穿透。设置此样式后，窗口对鼠标点击完全“隐形”，消息会传递给下方的窗口。
• WS_EX_TOPMOST：确保窗口始终位于最顶层，不会被非最顶层的窗口覆盖。
• WS_POPUP：通常用于无边框窗口，是悬浮窗口的常见样式。

2.2 分层窗口与透明度

设置了WS_EX_LAYERED后，可以通过SetLayeredWindowAttributes函数或UpdateLayeredWindow函数来管理透明度。

• 颜色键透明（Color Keying）：指定一种颜色（如纯绿）为透明色。简单，但不够灵活，边缘可能有毛刺。
• 阿尔法通道透明（Alpha Channel）：为整个窗口或每个像素设置0-255的透明度值。这是实现平滑半透明和异形窗口的主流方式。本项目通常结合Direct2D使用，实现每像素Alpha混合。

2.3 桌面窗口管理器（DWM）与桌面合成

现代Windows系统（Vista之后）使用DWM进行桌面合成。它负责将各个窗口的缓冲区合成最终的桌面图像。我们的叠加窗口也需要参与这个合成过程。UpdateLayeredWindow函数的工作就是与DWM协作，将我们提供的带有Alpha通道的位图合成到桌面上。

2.4 消息循环与点击穿透

即使设置了WS_EX_TRANSPARENT，窗口仍然需要运行一个消息泵（Message Pump）来维持存在。但这个循环通常会非常轻量，只处理极少数必要的消息（如WM_DESTROY），而将鼠标、键盘消息放行。

2.5 图形渲染：Direct2D vs. GDI

• GDI（Graphics Device Interface）：传统的Windows绘图API，简单但性能一般，对高级透明和动画支持较弱。
• Direct2D：硬件加速的即时模式2D图形API，性能卓越，完美支持Alpha混合、几何变换和复杂渲染。本项目推荐使用Direct2D来实现流畅的自定义绘制（如粒子系统、自定义准星）。

3. 环境准备与项目搭建

我们将创建一个最简单的C++项目来实现基础功能。你需要以下环境：

• 操作系统：Windows 10 或 Windows 11（完整支持DWM和Direct2D）。
• 开发环境：Visual Studio 2019 或更高版本（社区版即可）。
• 项目类型：桌面应用 -> Windows桌面向导应用程序。
• 依赖库：主要依赖Windows SDK，它包含了Win32 API和Direct2D。确保安装VS时勾选了“使用C++的桌面开发”和相应版本的Windows SDK。

创建项目步骤：

1. 打开Visual Studio，选择“创建新项目”。
2. 搜索并选择“Windows桌面向导”，点击下一步。
3. 输入项目名称，例如“DesktopOverlayDemo”。
4. 在“应用程序类型”中，选择“桌面应用程序(.exe)”。
5. 在“附加选项”中，取消勾选“预编译头”（为了示例简洁），勾选“空项目”。
6. 点击创建。

4. 核心流程拆解：创建透明可穿透窗口

我们将创建两个主要源文件：main.cpp（程序入口和窗口管理）和Graphics.h/cpp（Direct2D渲染封装）。

4.1 第一步：定义窗口类并注册

窗口类是窗口的模板。我们在main.cpp中实现。

// main.cpp #include <windows.h> #include <d2d1.h> // Direct2D 头文件 #pragma comment(lib, "d2d1.lib") // 链接Direct2D库 #include "Graphics.h" // 全局变量 Graphics* g_pGraphics = nullptr; // Direct2D渲染器 const wchar_t g_szClassName[] = L"DesktopOverlayWindowClass"; // 窗口类名 // 窗口过程函数（处理消息） LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) { switch (msg) { case WM_CREATE: // 窗口创建时，初始化Direct2D渲染器 g_pGraphics = new Graphics(); if (!g_pGraphics->Init(hwnd)) { MessageBox(hwnd, L"Direct2D初始化失败！", L"错误", MB_ICONERROR); return -1; // 创建失败 } return 0; case WM_PAINT: // 绘制窗口内容 if (g_pGraphics) { g_pGraphics->BeginDraw(); g_pGraphics->ClearScreen(0.0f, 0.0f, 0.0f, 0.0f); // 透明黑色背景 // 在这里添加你的绘制代码，例如绘制准星 DrawCustomCrosshair(g_pGraphics); g_pGraphics->EndDraw(); } ValidateRect(hwnd, nullptr); // 验证客户区，避免持续绘制 return 0; case WM_DESTROY: // 窗口销毁时，清理资源 if (g_pGraphics) { delete g_pGraphics; g_pGraphics = nullptr; } PostQuitMessage(0); return 0; default: return DefWindowProc(hwnd, msg, wParam, lParam); // 默认消息处理 } } // 注册窗口类 bool RegisterWindowClass(HINSTANCE hInstance) { WNDCLASSEX wc = {}; wc.cbSize = sizeof(WNDCLASSEX); wc.style = CS_HREDRAW | CS_VREDRAW; wc.lpfnWndProc = WndProc; // 设置窗口过程 wc.hInstance = hInstance; wc.hCursor = LoadCursor(nullptr, IDC_ARROW); wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1); wc.lpszClassName = g_szClassName; return RegisterClassEx(&wc) != 0; }

4.2 第二步：创建并显示叠加窗口

这是最关键的一步，设置正确的窗口样式。

// main.cpp (续) HWND CreateOverlayWindow(HINSTANCE hInstance, int nCmdShow) { // 计算窗口位置和大小（示例：全屏窗口） int screenWidth = GetSystemMetrics(SM_CXSCREEN); int screenHeight = GetSystemMetrics(SM_CYSCREEN); // 创建窗口 - 注意扩展样式的设置 HWND hwnd = CreateWindowEx( WS_EX_LAYERED | // 分层窗口，用于透明 WS_EX_TRANSPARENT | // 点击穿透 WS_EX_TOPMOST | // 始终置顶 WS_EX_TOOLWINDOW, // 不显示在任务栏 g_szClassName, // 窗口类名 L"Desktop Overlay", // 窗口标题 WS_POPUP, // 无边框窗口 0, 0, // 位置 (x, y) screenWidth, screenHeight, // 大小 nullptr, nullptr, hInstance, nullptr); if (!hwnd) { return nullptr; } // 关键：设置分层窗口属性，实现透明度 // 使用 ULW_ALPHA 标志和 255 表示完全不透明（背景透明靠ClearScreen的Alpha=0） // 实际透明度由我们在Direct2D中绘制的颜色Alpha值决定 SetLayeredWindowAttributes(hwnd, 0, 255, LWA_ALPHA); ShowWindow(hwnd, nCmdShow); UpdateWindow(hwnd); return hwnd; }

代码解释：

• WS_EX_LAYERED | WS_EX_TRANSPARENT | WS_EX_TOPMOST是核心组合。它创建了一个分层、可穿透且置顶的窗口。
• WS_POPUP样式移除了标题栏和边框。
• WS_EX_TOOLWINDOW使窗口不显示在任务栏，更像一个辅助工具。
• SetLayeredWindowAttributes(hwnd, 0, 255, LWA_ALPHA)告诉系统本窗口使用Alpha通道。窗口整体的不透明度参数是255（完全不透明），但因为我们用Direct2D绘制时使用了透明色（Alpha=0），所以窗口内容区域是透明的。

4.3 第三步：实现Direct2D渲染器

我们封装一个简单的Graphics类来管理Direct2D资源。

// Graphics.h #pragma once #include <d2d1.h> class Graphics { ID2D1Factory* pFactory; ID2D1HwndRenderTarget* pRenderTarget; ID2D1SolidColorBrush* pBrush; HWND hwnd; public: Graphics(); ~Graphics(); bool Init(HWND hwnd); void BeginDraw(); void EndDraw(); void ClearScreen(float r, float g, float b, float a); ID2D1RenderTarget* GetRenderTarget() { return pRenderTarget; } ID2D1SolidColorBrush* GetBrush() { return pBrush; } };

// Graphics.cpp #include "Graphics.h" #include <assert.h> Graphics::Graphics() { pFactory = nullptr; pRenderTarget = nullptr; pBrush = nullptr; hwnd = nullptr; } Graphics::~Graphics() { if (pBrush) pBrush->Release(); if (pRenderTarget) pRenderTarget->Release(); if (pFactory) pFactory->Release(); } bool Graphics::Init(HWND windowHandle) { hwnd = windowHandle; HRESULT hr = D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, &pFactory); if (FAILED(hr)) return false; RECT rect; GetClientRect(hwnd, &rect); hr = pFactory->CreateHwndRenderTarget( D2D1::RenderTargetProperties(), D2D1::HwndRenderTargetProperties(hwnd, D2D1::SizeU(rect.right, rect.bottom)), &pRenderTarget ); if (FAILED(hr)) return false; hr = pRenderTarget->CreateSolidColorBrush(D2D1::ColorF(1.0f, 1.0f, 1.0f, 1.0f), &pBrush); // 白色画笔，不透明 if (FAILED(hr)) return false; return true; } void Graphics::BeginDraw() { pRenderTarget->BeginDraw(); } void Graphics::EndDraw() { pRenderTarget->EndDraw(); } void Graphics::ClearScreen(float r, float g, float b, float a) { pRenderTarget->Clear(D2D1::ColorF(r, g, b, a)); }

4.4 第四步：主函数与消息循环

最后，将一切串联起来。

// main.cpp (续) int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) { // 1. 注册窗口类 if (!RegisterWindowClass(hInstance)) { MessageBox(nullptr, L"窗口类注册失败！", L"错误", MB_ICONERROR); return 1; } // 2. 创建叠加窗口 HWND hwnd = CreateOverlayWindow(hInstance, nCmdShow); if (!hwnd) { MessageBox(nullptr, L"窗口创建失败！", L"错误", MB_ICONERROR); return 1; } // 3. 主消息循环 MSG msg = {}; while (GetMessage(&msg, nullptr, 0, 0)) { TranslateMessage(&msg); DispatchMessage(&msg); } return (int)msg.wParam; }

5. 功能实现：自定义准星与粒子下落

基础框架搭建好后，我们就可以实现具体的功能了。我们在WM_PAINT消息的处理中添加绘制代码。

5.1 实现自定义准星

在main.cpp中添加一个绘制函数，并在WM_PAINT中调用。

// main.cpp (在WndProc函数前添加辅助函数) void DrawCustomCrosshair(Graphics* pGraphics) { if (!pGraphics || !pGraphics->GetRenderTarget() || !pGraphics->GetBrush()) return; ID2D1RenderTarget* pRT = pGraphics->GetRenderTarget(); ID2D1SolidColorBrush* pBrush = pGraphics->GetBrush(); // 获取屏幕中心（假设窗口是全屏的） RECT rect; GetClientRect(GetActiveWindow(), &rect); // 注意：这里获取的是前台窗口，更准确的做法是获取叠加窗口自身的大小 // 更稳健的做法：在WM_SIZE消息中缓存窗口大小，这里我们用简单示例 int centerX = rect.right / 2; int centerY = rect.bottom / 2; int crosshairSize = 20; int lineThickness = 2; // 设置准星颜色和透明度 (RGBA: 红色， 50%透明) pBrush->SetColor(D2D1::ColorF(1.0f, 0.0f, 0.0f, 0.5f)); // 绘制水平线 D2D1_RECT_F horizontalLine = D2D1::RectF( centerX - crosshairSize, centerY - lineThickness / 2.0f, centerX + crosshairSize, centerY + lineThickness / 2.0f ); pRT->FillRectangle(horizontalLine, pBrush); // 绘制垂直线 D2D1_RECT_F verticalLine = D2D1::RectF( centerX - lineThickness / 2.0f, centerY - crosshairSize, centerX + lineThickness / 2.0f, centerY + crosshairSize ); pRT->FillRectangle(verticalLine, pBrush); // 可选：绘制中心点 float dotRadius = 3.0f; D2D1_ELLIPSE dot = D2D1::Ellipse(D2D1::Point2F(centerX, centerY), dotRadius, dotRadius); pBrush->SetColor(D2D1::ColorF(0.0f, 1.0f, 0.0f, 0.8f)); // 绿色中心点 pRT->FillEllipse(dot, pBrush); }

然后在WM_PAINT案例中调用它：

case WM_PAINT: if (g_pGraphics) { g_pGraphics->BeginDraw(); g_pGraphics->ClearScreen(0.0f, 0.0f, 0.0f, 0.0f); // 透明背景 DrawCustomCrosshair(g_pGraphics); // 绘制准星 g_pGraphics->EndDraw(); } ValidateRect(hwnd, nullptr); return 0;

5.2 实现简易粒子下落系统

粒子系统稍复杂，需要状态管理和每帧更新。我们需要引入一个简单的游戏循环。这里我们使用SetTimer来模拟定时更新。

第一步：定义粒子结构体和系统在main.cpp顶部或单独头文件中定义。

// Particle.h (或直接在main.cpp顶部) #pragma once #include <vector> #include <random> struct Particle { float x, y; // 位置 float vx, vy; // 速度 float life; // 生命周期 (0.0 - 1.0) float size; // 大小 D2D1_COLOR_F color; // 颜色 }; class ParticleSystem { private: std::vector<Particle> particles; std::default_random_engine generator; std::uniform_real_distribution<float> dist{0.0f, 1.0f}; int screenWidth, screenHeight; public: ParticleSystem(int width, int height) : screenWidth(width), screenHeight(height) { // 初始化一些粒子 for (int i = 0; i < 100; ++i) { ResetParticle(i); } } void ResetParticle(size_t index) { if (index >= particles.size()) { particles.resize(index + 1); } Particle& p = particles[index]; p.x = dist(generator) * screenWidth; p.y = 0.0f; // 从顶部开始 p.vx = (dist(generator) - 0.5f) * 0.5f; // 随机水平速度 p.vy = dist(generator) * 2.0f + 1.0f; // 下落速度 p.life = 1.0f; p.size = dist(generator) * 5.0f + 2.0f; // 随机颜色，例如蓝色系 p.color = D2D1::ColorF(dist(generator) * 0.5f, dist(generator) * 0.5f, 1.0f, 0.7f); } void Update(float deltaTime) { for (size_t i = 0; i < particles.size(); ++i) { Particle& p = particles[i]; p.x += p.vx; p.y += p.vy; p.life -= 0.01f; // 生命衰减 // 如果粒子超出屏幕或生命结束，重置它 if (p.y > screenHeight || p.x < 0 || p.x > screenWidth || p.life <= 0.0f) { ResetParticle(i); } } } void Draw(ID2D1RenderTarget* pRT, ID2D1SolidColorBrush* pBrush) { for (const auto& p : particles) { pBrush->SetColor(D2D1::ColorF(p.color.r, p.color.g, p.color.b, p.color.a * p.life)); // 生命结束时渐隐 D2D1_ELLIPSE ellipse = D2D1::Ellipse(D2D1::Point2F(p.x, p.y), p.size, p.size); pRT->FillEllipse(ellipse, pBrush); } } };

第二步：集成到主程序在main.cpp中声明全局粒子系统，并设置定时器。

// main.cpp (全局变量区) Graphics* g_pGraphics = nullptr; ParticleSystem* g_pParticleSystem = nullptr; // 新增 const wchar_t g_szClassName[] = L"DesktopOverlayWindowClass"; // 在WM_CREATE中初始化粒子系统 case WM_CREATE: g_pGraphics = new Graphics(); if (!g_pGraphics->Init(hwnd)) { MessageBox(hwnd, L"Direct2D初始化失败！", L"错误", MB_ICONERROR); return -1; } // 获取窗口大小用于粒子系统 RECT rc; GetClientRect(hwnd, &rc); g_pParticleSystem = new ParticleSystem(rc.right, rc.bottom); // 设置一个定时器，每16毫秒（约60FPS）触发一次WM_TIMER SetTimer(hwnd, 1, 16, nullptr); return 0; // 处理WM_TIMER消息，更新并重绘 case WM_TIMER: if (g_pParticleSystem) { g_pParticleSystem->Update(0.016f); // 假设16ms InvalidateRect(hwnd, nullptr, FALSE); // 请求重绘 } return 0; // 修改WM_PAINT，绘制粒子 case WM_PAINT: if (g_pGraphics) { g_pGraphics->BeginDraw(); g_pGraphics->ClearScreen(0.0f, 0.0f, 0.0f, 0.0f); // DrawCustomCrosshair(g_pGraphics); // 可以选择绘制准星或粒子 if (g_pParticleSystem) { g_pParticleSystem->Draw(g_pGraphics->GetRenderTarget(), g_pGraphics->GetBrush()); } g_pGraphics->EndDraw(); } ValidateRect(hwnd, nullptr); return 0; // 在WM_DESTROY中清理 case WM_DESTROY: KillTimer(hwnd, 1); // 销毁定时器 if (g_pParticleSystem) { delete g_pParticleSystem; g_pParticleSystem = nullptr; } if (g_pGraphics) { delete g_pGraphics; g_pGraphics = nullptr; } PostQuitMessage(0); return 0;

6. 运行结果与效果验证

完成上述代码后，编译并运行项目（按F5或Ctrl+F5）。

预期效果：

1. 一个全屏的、完全透明的窗口被创建。
2. 如果你启用了准星绘制，屏幕中央会出现一个红色半透明的十字准星。关键验证：你可以用鼠标点击准星下方的任何程序（如浏览器、资源管理器），操作会正常进行，证明点击穿透成功。
3. 如果你启用了粒子系统，屏幕上会有蓝色系的粒子从顶部飘落，并且逐渐消失。这些粒子不会干扰你的任何鼠标和键盘操作。

如何验证功能：

• 置顶测试：打开一个全屏窗口（如游戏或视频），叠加窗口应依然显示在最前面。
• 穿透测试：尝试点击叠加窗口显示的区域，应该能直接操作到下层的窗口。
• 透明度测试：在ClearScreen函数中修改Alpha值（第四个参数），观察整体透明度变化。注意，我们使用的是每像素Alpha，所以背景为0，绘制的图形可以有自己的Alpha。

7. 常见问题与排查思路

8. 最佳实践与工程建议

将一个小Demo变成可维护、可扩展的项目，需要注意以下几点：

1. 分离关注点：将窗口管理、图形渲染、业务逻辑（如准星、粒子）分离到不同的类中。本文示例为了简洁放在一起，实际项目应更好分层。
2. 智能资源管理：使用ComPtr（WRL库）或std::unique_ptr配合自定义删除器来管理DirectX COM对象（如ID2D1RenderTarget），避免手动Release和内存泄漏。
3. 高性能渲染：
   • 避免在WM_PAINT外绘制：Direct2D渲染应在BeginDraw/EndDraw对中完成。
   • 使用双缓冲：Direct2D的HwndRenderTarget默认在内部处理，通常无需额外操作。
   • 限制重绘区域：如果只有小部分区域变化，使用InvalidateRect指定脏矩形，而非整个客户区。
4. 稳定的游戏循环：对于粒子系统等动态内容，SetTimer不够精确。对于要求高的场景，可以：
   • 使用多媒体定时器(timeSetEvent)。
   • 创建独立的渲染线程，使用高精度计时器（如QueryPerformanceCounter）控制帧率。
   • 在WM_TIMER中只更新状态，通过InvalidateRect触发绘制，让主消息循环保持响应。
5. 配置化：将准星颜色、大小、粒子数量、颜色等参数设计为可配置（如通过配置文件或注册表），方便用户自定义。
6. 兼容性考虑：
   • 检查Windows版本，对旧系统提供回退方案（如使用GDI）。
   • 处理DPI缩放：使用SetProcessDpiAwareness设置DPI感知，并在WM_DPICHANGED消息中调整渲染目标大小。
7. 安装与部署：项目依赖Windows SDK和运行时库。如果分发，可能需要打包相应的VC++ Redistributable。

9. 总结与扩展方向

通过本文，我们实现了一个功能完整的桌面叠加透明窗口框架，并在此基础上实现了自定义准星和粒子下落两个经典功能。其核心技术要点在于WS_EX_LAYERED、WS_EX_TRANSPARENT、WS_EX_TOPMOST窗口样式的组合，以及Direct2D用于高性能、带Alpha通道的图形绘制。

这个框架的潜力远不止于此，你可以基于它扩展出许多实用工具：

• 系统监控悬浮窗：读取CPU/内存/GPU数据，并实时绘制图表。
• 全局快捷键提示：在屏幕角落显示当前激活的快捷键组合。
• 屏幕取色器：鼠标悬浮时放大区域并显示RGB/HEX值。
• 专注辅助工具：在屏幕四周绘制深色遮罩，高亮中心工作区。
• 桌面宠物或挂件：绘制交互式的动画角色。

下一步深入学习的方向：

1. 深入Direct2D/DirectX：学习更多几何图形、位图渲染、文本渲染、特效（如阴影、模糊）的使用。
2. 探索其他渲染后端：如使用OpenGL或Vulkan在叠加窗口中进行3D渲染。
3. 进程间通信：让你的叠加窗口与其他应用（如游戏、监控软件）通信，动态改变显示内容。
4. 注入与挂钩：更高级的技术，可以将你的代码注入到目标进程，实现更深度的集成（注意安全性和合法性）。

掌握桌面叠加窗口技术，为你打开了一扇定制化Windows桌面体验的大门。从提升游戏体验到打造专属效率工具，可能性只受限于你的想象力。建议将本文的示例代码作为起点，逐步探索和构建属于你自己的“第二屏幕”体验。