2020-08-26 00:55:29 +08:00
|
|
|
#include "pch.h"
|
|
|
|
#include "ZoneWindowDrawing.h"
|
|
|
|
|
2020-10-26 16:07:11 +08:00
|
|
|
#include <algorithm>
|
|
|
|
#include <map>
|
2020-08-26 00:55:29 +08:00
|
|
|
#include <string>
|
2020-10-26 16:07:11 +08:00
|
|
|
#include <vector>
|
2020-08-26 00:55:29 +08:00
|
|
|
|
|
|
|
namespace NonLocalizable
|
|
|
|
{
|
|
|
|
const wchar_t SegoeUiFont[] = L"Segoe ui";
|
|
|
|
}
|
2020-10-23 20:37:14 +08:00
|
|
|
|
|
|
|
float ZoneWindowDrawing::GetAnimationAlpha()
|
|
|
|
{
|
|
|
|
// Lock is being held
|
2020-10-27 00:37:56 +08:00
|
|
|
if (!m_animation)
|
2020-10-23 20:37:14 +08:00
|
|
|
{
|
|
|
|
return 1.f;
|
|
|
|
}
|
|
|
|
|
|
|
|
auto tNow = std::chrono::steady_clock().now();
|
2020-10-27 00:37:56 +08:00
|
|
|
auto alpha = (tNow - m_animation->tStart).count() / (1e6f * m_animation->duration);
|
2020-10-23 20:37:14 +08:00
|
|
|
if (alpha < 1.f)
|
|
|
|
{
|
|
|
|
return alpha;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
return 1.f;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ID2D1Factory* ZoneWindowDrawing::GetD2DFactory()
|
|
|
|
{
|
2020-10-27 18:11:23 +08:00
|
|
|
static auto pD2DFactory = [] {
|
|
|
|
ID2D1Factory* res = nullptr;
|
|
|
|
D2D1CreateFactory(D2D1_FACTORY_TYPE_MULTI_THREADED, &res);
|
|
|
|
return res;
|
|
|
|
}();
|
2020-10-23 20:37:14 +08:00
|
|
|
return pD2DFactory;
|
|
|
|
}
|
|
|
|
|
|
|
|
IDWriteFactory* ZoneWindowDrawing::GetWriteFactory()
|
|
|
|
{
|
2020-10-27 18:11:23 +08:00
|
|
|
static auto pDWriteFactory = [] {
|
|
|
|
IUnknown* res = nullptr;
|
|
|
|
DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, __uuidof(IDWriteFactory), &res);
|
|
|
|
return reinterpret_cast<IDWriteFactory*>(res);
|
|
|
|
}();
|
|
|
|
return pDWriteFactory;
|
2020-10-23 20:37:14 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
D2D1_COLOR_F ZoneWindowDrawing::ConvertColor(COLORREF color)
|
|
|
|
{
|
|
|
|
return D2D1::ColorF(GetRValue(color) / 255.f,
|
|
|
|
GetGValue(color) / 255.f,
|
|
|
|
GetBValue(color) / 255.f,
|
|
|
|
1.f);
|
|
|
|
}
|
|
|
|
|
|
|
|
D2D1_RECT_F ZoneWindowDrawing::ConvertRect(RECT rect)
|
|
|
|
{
|
2020-10-27 22:37:12 +08:00
|
|
|
return D2D1::RectF((float)rect.left + 0.5f, (float)rect.top + 0.5f, (float)rect.right + 0.5f, (float)rect.bottom + 0.5f);
|
2020-10-23 20:37:14 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
ZoneWindowDrawing::ZoneWindowDrawing(HWND window)
|
|
|
|
{
|
|
|
|
m_window = window;
|
|
|
|
m_renderTarget = nullptr;
|
2020-10-23 21:22:45 +08:00
|
|
|
m_shouldRender = false;
|
2020-10-23 20:37:14 +08:00
|
|
|
|
|
|
|
// Obtain the size of the drawing area.
|
|
|
|
if (!GetClientRect(window, &m_clientRect))
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Create a Direct2D render target
|
|
|
|
GetD2DFactory()->CreateHwndRenderTarget(
|
|
|
|
D2D1::RenderTargetProperties(
|
|
|
|
D2D1_RENDER_TARGET_TYPE_DEFAULT,
|
|
|
|
D2D1::PixelFormat(DXGI_FORMAT_UNKNOWN, D2D1_ALPHA_MODE_PREMULTIPLIED)),
|
|
|
|
D2D1::HwndRenderTargetProperties(
|
|
|
|
window,
|
|
|
|
D2D1::SizeU(
|
|
|
|
m_clientRect.right - m_clientRect.left,
|
|
|
|
m_clientRect.bottom - m_clientRect.top)),
|
|
|
|
&m_renderTarget);
|
2020-10-23 21:22:45 +08:00
|
|
|
|
|
|
|
m_renderThread = std::thread([this]() {
|
|
|
|
while (!m_abortThread)
|
|
|
|
{
|
|
|
|
// Force repeated rendering while in the animation loop.
|
|
|
|
// Yield if low latency locking was requested
|
|
|
|
if (!m_lowLatencyLock)
|
|
|
|
{
|
|
|
|
float animationAlpha;
|
|
|
|
{
|
|
|
|
std::unique_lock lock(m_mutex);
|
|
|
|
animationAlpha = GetAnimationAlpha();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (animationAlpha < 1.f)
|
|
|
|
{
|
|
|
|
m_shouldRender = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Render();
|
|
|
|
}
|
|
|
|
});
|
2020-10-23 20:37:14 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void ZoneWindowDrawing::Render()
|
|
|
|
{
|
|
|
|
std::unique_lock lock(m_mutex);
|
|
|
|
|
|
|
|
if (!m_renderTarget)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-10-23 21:22:45 +08:00
|
|
|
m_cv.wait(lock, [this]() { return (bool)m_shouldRender; });
|
|
|
|
|
2020-10-23 20:37:14 +08:00
|
|
|
m_renderTarget->BeginDraw();
|
2020-10-23 21:22:45 +08:00
|
|
|
|
2020-10-23 20:37:14 +08:00
|
|
|
float animationAlpha = GetAnimationAlpha();
|
|
|
|
|
2020-10-23 21:22:45 +08:00
|
|
|
// Draw backdrop
|
|
|
|
m_renderTarget->Clear(D2D1::ColorF(0.f, 0.f, 0.f, 0.f));
|
|
|
|
|
2020-10-27 18:05:12 +08:00
|
|
|
ID2D1SolidColorBrush* textBrush = nullptr;
|
|
|
|
IDWriteTextFormat* textFormat = nullptr;
|
|
|
|
|
|
|
|
m_renderTarget->CreateSolidColorBrush(D2D1::ColorF(D2D1::ColorF::Black, animationAlpha), &textBrush);
|
|
|
|
auto writeFactory = GetWriteFactory();
|
|
|
|
|
|
|
|
if (writeFactory)
|
|
|
|
{
|
|
|
|
writeFactory->CreateTextFormat(NonLocalizable::SegoeUiFont, nullptr, DWRITE_FONT_WEIGHT_NORMAL, DWRITE_FONT_STYLE_NORMAL, DWRITE_FONT_STRETCH_NORMAL, 80.f, L"en-US", &textFormat);
|
|
|
|
}
|
|
|
|
|
2020-10-23 20:37:14 +08:00
|
|
|
for (auto drawableRect : m_sceneRects)
|
|
|
|
{
|
|
|
|
ID2D1SolidColorBrush* borderBrush = nullptr;
|
|
|
|
ID2D1SolidColorBrush* fillBrush = nullptr;
|
|
|
|
|
|
|
|
// Need to copy the rect from m_sceneRects
|
|
|
|
drawableRect.borderColor.a *= animationAlpha;
|
|
|
|
drawableRect.fillColor.a *= animationAlpha;
|
|
|
|
|
|
|
|
m_renderTarget->CreateSolidColorBrush(drawableRect.borderColor, &borderBrush);
|
|
|
|
m_renderTarget->CreateSolidColorBrush(drawableRect.fillColor, &fillBrush);
|
|
|
|
|
|
|
|
if (fillBrush)
|
|
|
|
{
|
|
|
|
m_renderTarget->FillRectangle(drawableRect.rect, fillBrush);
|
|
|
|
fillBrush->Release();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (borderBrush)
|
|
|
|
{
|
|
|
|
m_renderTarget->DrawRectangle(drawableRect.rect, borderBrush);
|
|
|
|
borderBrush->Release();
|
|
|
|
}
|
|
|
|
|
2020-10-27 22:32:24 +08:00
|
|
|
std::wstring idStr = std::to_wstring(drawableRect.id + 1);
|
2020-10-23 20:37:14 +08:00
|
|
|
|
|
|
|
if (textFormat && textBrush)
|
|
|
|
{
|
|
|
|
textFormat->SetTextAlignment(DWRITE_TEXT_ALIGNMENT_CENTER);
|
|
|
|
textFormat->SetParagraphAlignment(DWRITE_PARAGRAPH_ALIGNMENT_CENTER);
|
|
|
|
m_renderTarget->DrawTextW(idStr.c_str(), (UINT32)idStr.size(), textFormat, drawableRect.rect, textBrush);
|
|
|
|
}
|
2020-10-27 18:05:12 +08:00
|
|
|
}
|
2020-10-23 20:37:14 +08:00
|
|
|
|
2020-10-27 18:05:12 +08:00
|
|
|
if (textFormat)
|
|
|
|
{
|
|
|
|
textFormat->Release();
|
|
|
|
}
|
2020-10-23 20:37:14 +08:00
|
|
|
|
2020-10-27 18:05:12 +08:00
|
|
|
if (textBrush)
|
|
|
|
{
|
|
|
|
textBrush->Release();
|
2020-10-23 20:37:14 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
m_renderTarget->EndDraw();
|
2020-10-23 21:22:45 +08:00
|
|
|
m_shouldRender = false;
|
2020-10-23 20:37:14 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void ZoneWindowDrawing::Hide()
|
|
|
|
{
|
2020-10-27 09:13:54 +08:00
|
|
|
m_lowLatencyLock = true;
|
2020-10-23 20:37:14 +08:00
|
|
|
std::unique_lock lock(m_mutex);
|
2020-10-27 09:13:54 +08:00
|
|
|
m_lowLatencyLock = false;
|
|
|
|
|
2020-10-27 00:37:56 +08:00
|
|
|
if (m_animation)
|
2020-10-23 20:37:14 +08:00
|
|
|
{
|
2020-10-27 00:37:56 +08:00
|
|
|
m_animation.reset();
|
2020-10-23 20:37:14 +08:00
|
|
|
ShowWindow(m_window, SW_HIDE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void ZoneWindowDrawing::Show(unsigned animationMillis)
|
|
|
|
{
|
2020-10-23 21:22:45 +08:00
|
|
|
m_lowLatencyLock = true;
|
2020-10-23 20:37:14 +08:00
|
|
|
std::unique_lock lock(m_mutex);
|
2020-10-23 21:22:45 +08:00
|
|
|
m_lowLatencyLock = false;
|
|
|
|
|
2020-10-27 00:37:56 +08:00
|
|
|
if (!m_animation)
|
2020-10-23 20:37:14 +08:00
|
|
|
{
|
|
|
|
ShowWindow(m_window, SW_SHOWDEFAULT);
|
2020-10-27 00:37:56 +08:00
|
|
|
if (animationMillis > 0)
|
|
|
|
{
|
|
|
|
m_animation.emplace(AnimationInfo{ std::chrono::steady_clock().now(), animationMillis });
|
|
|
|
}
|
2020-10-23 21:22:45 +08:00
|
|
|
m_shouldRender = true;
|
|
|
|
m_cv.notify_all();
|
2020-10-23 20:37:14 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-10-26 19:20:01 +08:00
|
|
|
void ZoneWindowDrawing::DrawActiveZoneSet(const IZoneSet::ZonesMap& zones,
|
2020-10-23 20:37:14 +08:00
|
|
|
const std::vector<size_t>& highlightZones,
|
|
|
|
winrt::com_ptr<IZoneWindowHost> host)
|
|
|
|
{
|
2020-10-23 21:22:45 +08:00
|
|
|
m_lowLatencyLock = true;
|
2020-10-23 20:37:14 +08:00
|
|
|
std::unique_lock lock(m_mutex);
|
2020-10-23 21:22:45 +08:00
|
|
|
m_lowLatencyLock = false;
|
2020-10-23 20:37:14 +08:00
|
|
|
|
|
|
|
m_sceneRects = {};
|
|
|
|
|
|
|
|
auto borderColor = ConvertColor(host->GetZoneBorderColor());
|
|
|
|
auto inactiveColor = ConvertColor(host->GetZoneColor());
|
|
|
|
auto highlightColor = ConvertColor(host->GetZoneHighlightColor());
|
|
|
|
|
|
|
|
inactiveColor.a = host->GetZoneHighlightOpacity() / 100.f;
|
|
|
|
highlightColor.a = host->GetZoneHighlightOpacity() / 100.f;
|
|
|
|
|
2020-10-26 19:20:01 +08:00
|
|
|
std::vector<bool> isHighlighted(zones.size() + 1, false);
|
2020-10-23 20:37:14 +08:00
|
|
|
for (size_t x : highlightZones)
|
|
|
|
{
|
|
|
|
isHighlighted[x] = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// First draw the inactive zones
|
2020-10-26 19:20:01 +08:00
|
|
|
for (const auto& [zoneId, zone] : zones)
|
2020-10-23 20:37:14 +08:00
|
|
|
{
|
|
|
|
if (!zone)
|
|
|
|
{
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!isHighlighted[zoneId])
|
|
|
|
{
|
|
|
|
DrawableRect drawableRect{
|
|
|
|
.rect = ConvertRect(zone->GetZoneRect()),
|
|
|
|
.borderColor = borderColor,
|
|
|
|
.fillColor = inactiveColor,
|
|
|
|
.id = zone->Id()
|
|
|
|
};
|
|
|
|
|
|
|
|
m_sceneRects.push_back(drawableRect);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Draw the active zones on top of the inactive zones
|
2020-10-26 19:20:01 +08:00
|
|
|
for (const auto& [zoneId, zone] : zones)
|
2020-10-23 20:37:14 +08:00
|
|
|
{
|
|
|
|
if (!zone)
|
|
|
|
{
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (isHighlighted[zoneId])
|
|
|
|
{
|
|
|
|
DrawableRect drawableRect{
|
|
|
|
.rect = ConvertRect(zone->GetZoneRect()),
|
|
|
|
.borderColor = borderColor,
|
|
|
|
.fillColor = highlightColor,
|
|
|
|
.id = zone->Id()
|
|
|
|
};
|
|
|
|
|
|
|
|
m_sceneRects.push_back(drawableRect);
|
|
|
|
}
|
|
|
|
}
|
2020-10-23 21:22:45 +08:00
|
|
|
|
|
|
|
m_shouldRender = true;
|
|
|
|
m_cv.notify_all();
|
|
|
|
}
|
|
|
|
|
|
|
|
void ZoneWindowDrawing::ForceRender()
|
|
|
|
{
|
|
|
|
m_lowLatencyLock = true;
|
|
|
|
std::unique_lock lock(m_mutex);
|
|
|
|
m_lowLatencyLock = false;
|
|
|
|
m_shouldRender = true;
|
|
|
|
m_cv.notify_all();
|
|
|
|
}
|
|
|
|
|
|
|
|
ZoneWindowDrawing::~ZoneWindowDrawing()
|
|
|
|
{
|
|
|
|
{
|
|
|
|
std::unique_lock lock(m_mutex);
|
|
|
|
m_abortThread = true;
|
|
|
|
m_shouldRender = true;
|
|
|
|
}
|
|
|
|
m_cv.notify_all();
|
|
|
|
m_renderThread.join();
|
2020-10-23 20:37:14 +08:00
|
|
|
}
|