991 lines
20 KiB
C++
991 lines
20 KiB
C++
// Copyright (c) 2016-2018 Kiwano - Nomango
|
||
//
|
||
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
||
// of this software and associated documentation files (the "Software"), to deal
|
||
// in the Software without restriction, including without limitation the rights
|
||
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||
// copies of the Software, and to permit persons to whom the Software is
|
||
// furnished to do so, subject to the following conditions:
|
||
//
|
||
// The above copyright notice and this permission notice shall be included in
|
||
// all copies or substantial portions of the Software.
|
||
//
|
||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||
// THE SOFTWARE.
|
||
|
||
#include "Renderer.h"
|
||
#include "../base/Logger.h"
|
||
#include "../base/Window.h"
|
||
#include "../utils/FileUtil.h"
|
||
|
||
namespace kiwano
|
||
{
|
||
RenderConfig::RenderConfig(Color clear_color, bool vsync)
|
||
: clear_color(clear_color)
|
||
, vsync(vsync)
|
||
{
|
||
}
|
||
|
||
Renderer::Renderer()
|
||
: hwnd_(nullptr)
|
||
, vsync_(true)
|
||
, clear_color_(Color::Black)
|
||
, resolution_mode_(ResolutionMode::Fixed)
|
||
{
|
||
}
|
||
|
||
Renderer::~Renderer()
|
||
{
|
||
}
|
||
|
||
void Renderer::Init(RenderConfig const& config)
|
||
{
|
||
SetClearColor(config.clear_color);
|
||
SetVSyncEnabled(config.vsync);
|
||
}
|
||
|
||
void Renderer::SetupComponent()
|
||
{
|
||
KGE_LOG(L"Creating device resources");
|
||
|
||
hwnd_ = Window::GetInstance()->GetHandle();
|
||
resolution_ = output_size_ = Window::GetInstance()->GetSize();
|
||
|
||
d2d_res_ = nullptr;
|
||
d3d_res_ = nullptr;
|
||
drawing_state_block_ = nullptr;
|
||
|
||
HRESULT hr = hwnd_ ? S_OK : E_FAIL;
|
||
|
||
// Direct2D device resources
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
hr = ID2DDeviceResources::Create(&d2d_res_);
|
||
}
|
||
|
||
// Direct3D device resources
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
#if defined(KGE_USE_DIRECTX10)
|
||
hr = ID3D10DeviceResources::Create(
|
||
&d3d_res_,
|
||
d2d_res_.get(),
|
||
hwnd_
|
||
);
|
||
#else
|
||
hr = ID3D11DeviceResources::Create(
|
||
&d3d_res_,
|
||
d2d_res_.get(),
|
||
hwnd_
|
||
);
|
||
#endif
|
||
}
|
||
|
||
// DrawingStateBlock
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
hr = d2d_res_->GetFactory()->CreateDrawingStateBlock(
|
||
&drawing_state_block_
|
||
);
|
||
}
|
||
|
||
// Other device resources
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
hr = CreateDeviceResources();
|
||
}
|
||
|
||
// FontFileLoader and FontCollectionLoader
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
hr = IFontCollectionLoader::Create(&font_collection_loader_);
|
||
}
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
hr = d2d_res_->GetDWriteFactory()->RegisterFontCollectionLoader(font_collection_loader_.get());
|
||
}
|
||
|
||
// ResourceFontFileLoader and ResourceFontCollectionLoader
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
hr = IResourceFontFileLoader::Create(&res_font_file_loader_);
|
||
}
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
hr = d2d_res_->GetDWriteFactory()->RegisterFontFileLoader(res_font_file_loader_.get());
|
||
}
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
hr = IResourceFontCollectionLoader::Create(&res_font_collection_loader_, res_font_file_loader_.get());
|
||
}
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
hr = d2d_res_->GetDWriteFactory()->RegisterFontCollectionLoader(res_font_collection_loader_.get());
|
||
}
|
||
|
||
ThrowIfFailed(hr);
|
||
}
|
||
|
||
void Renderer::DestroyComponent()
|
||
{
|
||
KGE_LOG(L"Destroying device resources");
|
||
|
||
RenderTarget::DiscardDeviceResources();
|
||
|
||
d2d_res_->GetDWriteFactory()->UnregisterFontFileLoader(res_font_file_loader_.get());
|
||
res_font_file_loader_.reset();
|
||
|
||
d2d_res_->GetDWriteFactory()->UnregisterFontCollectionLoader(res_font_collection_loader_.get());
|
||
res_font_collection_loader_.reset();
|
||
|
||
drawing_state_block_.reset();
|
||
d2d_res_.reset();
|
||
d3d_res_.reset();
|
||
}
|
||
|
||
void Renderer::BeforeRender()
|
||
{
|
||
HRESULT hr = S_OK;
|
||
|
||
if (!IsValid())
|
||
{
|
||
hr = E_UNEXPECTED;
|
||
}
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
render_target_->SaveDrawingState(drawing_state_block_.get());
|
||
BeginDraw();
|
||
}
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
hr = d3d_res_->ClearRenderTarget(clear_color_);
|
||
}
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
SetTransform(Matrix3x2{});
|
||
PushClipRect(Rect{ Point{}, resolution_ });
|
||
}
|
||
|
||
ThrowIfFailed(hr);
|
||
}
|
||
|
||
void Renderer::AfterRender()
|
||
{
|
||
HRESULT hr = S_OK;
|
||
|
||
if (!IsValid())
|
||
{
|
||
hr = E_UNEXPECTED;
|
||
}
|
||
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
PopClipRect();
|
||
|
||
EndDraw();
|
||
|
||
render_target_->RestoreDrawingState(drawing_state_block_.get());
|
||
}
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
hr = d3d_res_->Present(vsync_);
|
||
}
|
||
|
||
if (hr == DXGI_ERROR_DEVICE_REMOVED || hr == DXGI_ERROR_DEVICE_RESET)
|
||
{
|
||
// <20><><EFBFBD><EFBFBD> Direct3D <20>豸<EFBFBD><E8B1B8>ִ<EFBFBD>й<EFBFBD><D0B9><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʧ<EFBFBD><CAA7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ǰ<EFBFBD><C7B0><EFBFBD>豸<EFBFBD><E8B1B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Դ
|
||
hr = HandleDeviceLost();
|
||
}
|
||
|
||
ThrowIfFailed(hr);
|
||
}
|
||
|
||
void Renderer::HandleMessage(HWND hwnd, UInt32 msg, WPARAM wparam, LPARAM lparam)
|
||
{
|
||
switch (msg)
|
||
{
|
||
case WM_SIZE:
|
||
{
|
||
UInt32 width = LOWORD(lparam);
|
||
UInt32 height = HIWORD(lparam);
|
||
|
||
ResizeTarget(width, height);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
HRESULT Renderer::CreateDeviceResources()
|
||
{
|
||
KGE_ASSERT(d2d_res_);
|
||
|
||
HRESULT hr = RenderTarget::CreateDeviceResources(
|
||
d2d_res_->GetDeviceContext(),
|
||
d2d_res_
|
||
);
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
SetAntialiasMode(antialias_);
|
||
SetTextAntialiasMode(text_antialias_);
|
||
}
|
||
return hr;
|
||
}
|
||
|
||
HRESULT Renderer::HandleDeviceLost()
|
||
{
|
||
HRESULT hr = d3d_res_->HandleDeviceLost();
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
hr = CreateDeviceResources();
|
||
}
|
||
return hr;
|
||
}
|
||
|
||
void Renderer::CreateTexture(Texture& texture, String const& file_path)
|
||
{
|
||
HRESULT hr = S_OK;
|
||
if (!d2d_res_)
|
||
{
|
||
hr = E_UNEXPECTED;
|
||
}
|
||
|
||
if (!FileUtil::ExistsFile(file_path))
|
||
{
|
||
KGE_WARNING_LOG(L"Texture file '%s' not found!", file_path.c_str());
|
||
hr = E_FAIL;
|
||
}
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
ComPtr<IWICBitmapDecoder> decoder;
|
||
hr = d2d_res_->CreateBitmapDecoderFromFile(decoder, file_path);
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
ComPtr<IWICBitmapFrameDecode> source;
|
||
hr = decoder->GetFrame(0, &source);
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
ComPtr<IWICFormatConverter> converter;
|
||
hr = d2d_res_->CreateBitmapConverter(
|
||
converter,
|
||
source,
|
||
GUID_WICPixelFormat32bppPBGRA,
|
||
WICBitmapDitherTypeNone,
|
||
nullptr,
|
||
0.f,
|
||
WICBitmapPaletteTypeMedianCut
|
||
);
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
ComPtr<ID2D1Bitmap> bitmap;
|
||
hr = d2d_res_->CreateBitmapFromConverter(
|
||
bitmap,
|
||
nullptr,
|
||
converter
|
||
);
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
texture.SetBitmap(bitmap);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (FAILED(hr))
|
||
{
|
||
KGE_WARNING_LOG(L"Load texture failed with HRESULT of %08X!", hr);
|
||
}
|
||
}
|
||
|
||
void Renderer::CreateTexture(Texture& texture, Resource const& resource)
|
||
{
|
||
HRESULT hr = S_OK;
|
||
if (!d2d_res_)
|
||
{
|
||
hr = E_UNEXPECTED;
|
||
}
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
ComPtr<IWICBitmapDecoder> decoder;
|
||
hr = d2d_res_->CreateBitmapDecoderFromResource(decoder, resource);
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
ComPtr<IWICBitmapFrameDecode> source;
|
||
hr = decoder->GetFrame(0, &source);
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
ComPtr<IWICFormatConverter> converter;
|
||
hr = d2d_res_->CreateBitmapConverter(
|
||
converter,
|
||
source,
|
||
GUID_WICPixelFormat32bppPBGRA,
|
||
WICBitmapDitherTypeNone,
|
||
nullptr,
|
||
0.f,
|
||
WICBitmapPaletteTypeMedianCut
|
||
);
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
ComPtr<ID2D1Bitmap> bitmap;
|
||
hr = d2d_res_->CreateBitmapFromConverter(
|
||
bitmap,
|
||
nullptr,
|
||
converter
|
||
);
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
texture.SetBitmap(bitmap);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (FAILED(hr))
|
||
{
|
||
KGE_WARNING_LOG(L"Load texture failed with HRESULT of %08X!", hr);
|
||
}
|
||
}
|
||
|
||
void Renderer::CreateGifImage(GifImage& gif, String const& file_path)
|
||
{
|
||
HRESULT hr = S_OK;
|
||
if (!d2d_res_)
|
||
{
|
||
hr = E_UNEXPECTED;
|
||
}
|
||
|
||
if (!FileUtil::ExistsFile(file_path))
|
||
{
|
||
KGE_WARNING_LOG(L"Gif texture file '%s' not found!", file_path.c_str());
|
||
hr = E_FAIL;
|
||
}
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
ComPtr<IWICBitmapDecoder> decoder;
|
||
hr = d2d_res_->CreateBitmapDecoderFromFile(decoder, file_path);
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
gif.SetDecoder(decoder);
|
||
}
|
||
}
|
||
|
||
if (FAILED(hr))
|
||
{
|
||
KGE_WARNING_LOG(L"Load GIF texture failed with HRESULT of %08X!", hr);
|
||
}
|
||
}
|
||
|
||
void Renderer::CreateGifImage(GifImage& gif, Resource const& resource)
|
||
{
|
||
HRESULT hr = S_OK;
|
||
if (!d2d_res_)
|
||
{
|
||
hr = E_UNEXPECTED;
|
||
}
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
ComPtr<IWICBitmapDecoder> decoder;
|
||
hr = d2d_res_->CreateBitmapDecoderFromResource(decoder, resource);
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
gif.SetDecoder(decoder);
|
||
}
|
||
}
|
||
|
||
if (FAILED(hr))
|
||
{
|
||
KGE_WARNING_LOG(L"Load GIF texture failed with HRESULT of %08X!", hr);
|
||
}
|
||
}
|
||
|
||
void Renderer::CreateGifImageFrame(GifImage::Frame& frame, GifImage const& gif, UInt32 frame_index)
|
||
{
|
||
HRESULT hr = S_OK;
|
||
if (!d2d_res_)
|
||
{
|
||
hr = E_UNEXPECTED;
|
||
}
|
||
|
||
if (gif.GetDecoder() == nullptr)
|
||
{
|
||
hr = E_INVALIDARG;
|
||
}
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
ComPtr<IWICBitmapFrameDecode> wic_frame;
|
||
HRESULT hr = gif.GetDecoder()->GetFrame(frame_index, &wic_frame);
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
ComPtr<IWICFormatConverter> converter;
|
||
d2d_res_->CreateBitmapConverter(
|
||
converter,
|
||
wic_frame,
|
||
GUID_WICPixelFormat32bppPBGRA,
|
||
WICBitmapDitherTypeNone,
|
||
nullptr,
|
||
0.f,
|
||
WICBitmapPaletteTypeCustom
|
||
);
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
ComPtr<ID2D1Bitmap> raw_bitmap;
|
||
hr = d2d_res_->CreateBitmapFromConverter(
|
||
raw_bitmap,
|
||
nullptr,
|
||
converter
|
||
);
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
frame.raw.SetBitmap(raw_bitmap);
|
||
}
|
||
}
|
||
}
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
PROPVARIANT prop_val;
|
||
PropVariantInit(&prop_val);
|
||
|
||
// Get Metadata Query Reader from the frame
|
||
ComPtr<IWICMetadataQueryReader> metadata_reader;
|
||
hr = wic_frame->GetMetadataQueryReader(&metadata_reader);
|
||
|
||
// Get the Metadata for the current frame
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
hr = metadata_reader->GetMetadataByName(L"/imgdesc/Left", &prop_val);
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
hr = (prop_val.vt == VT_UI2 ? S_OK : E_FAIL);
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
frame.rect.left_top.x = static_cast<Float32>(prop_val.uiVal);
|
||
}
|
||
PropVariantClear(&prop_val);
|
||
}
|
||
}
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
hr = metadata_reader->GetMetadataByName(L"/imgdesc/Top", &prop_val);
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
hr = (prop_val.vt == VT_UI2 ? S_OK : E_FAIL);
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
frame.rect.left_top.y = static_cast<Float32>(prop_val.uiVal);
|
||
}
|
||
PropVariantClear(&prop_val);
|
||
}
|
||
}
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
hr = metadata_reader->GetMetadataByName(L"/imgdesc/Width", &prop_val);
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
hr = (prop_val.vt == VT_UI2 ? S_OK : E_FAIL);
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
frame.rect.right_bottom.x = frame.rect.left_top.x + static_cast<Float32>(prop_val.uiVal);
|
||
}
|
||
PropVariantClear(&prop_val);
|
||
}
|
||
}
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
hr = metadata_reader->GetMetadataByName(L"/imgdesc/Height", &prop_val);
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
hr = (prop_val.vt == VT_UI2 ? S_OK : E_FAIL);
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
frame.rect.right_bottom.y = frame.rect.left_top.y + static_cast<Float32>(prop_val.uiVal);
|
||
}
|
||
PropVariantClear(&prop_val);
|
||
}
|
||
}
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
hr = metadata_reader->GetMetadataByName(L"/grctlext/Delay", &prop_val);
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
hr = (prop_val.vt == VT_UI2 ? S_OK : E_FAIL);
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
UInt32 udelay = 0;
|
||
hr = UIntMult(prop_val.uiVal, 10, &udelay);
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
frame.delay.SetMilliseconds(static_cast<long>(udelay));
|
||
}
|
||
}
|
||
PropVariantClear(&prop_val);
|
||
}
|
||
else
|
||
{
|
||
frame.delay = 0;
|
||
}
|
||
}
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
hr = metadata_reader->GetMetadataByName(L"/grctlext/Disposal", &prop_val);
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
hr = (prop_val.vt == VT_UI1) ? S_OK : E_FAIL;
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
frame.disposal_type = GifImage::DisposalType(prop_val.bVal);
|
||
}
|
||
::PropVariantClear(&prop_val);
|
||
}
|
||
else
|
||
{
|
||
frame.disposal_type = GifImage::DisposalType::Unknown;
|
||
}
|
||
}
|
||
|
||
::PropVariantClear(&prop_val);
|
||
}
|
||
}
|
||
|
||
if (FAILED(hr))
|
||
{
|
||
KGE_WARNING_LOG(L"Load GIF frame failed with HRESULT of %08X!", hr);
|
||
}
|
||
}
|
||
|
||
void Renderer::CreateFontCollection(FontCollection& collection, Vector<String> const& file_paths)
|
||
{
|
||
HRESULT hr = S_OK;
|
||
if (!d2d_res_)
|
||
{
|
||
hr = E_UNEXPECTED;
|
||
}
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
for (const auto& file_path : file_paths)
|
||
{
|
||
if (!FileUtil::ExistsFile(file_path))
|
||
{
|
||
KGE_WARNING_LOG(L"Font file '%s' not found!", file_path.c_str());
|
||
hr = E_FAIL;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
LPVOID collection_key = nullptr;
|
||
UInt32 collection_key_size = 0;
|
||
|
||
hr = font_collection_loader_->AddFilePaths(file_paths, &collection_key, &collection_key_size);
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
ComPtr<IDWriteFontCollection> font_collection;
|
||
hr = d2d_res_->GetDWriteFactory()->CreateCustomFontCollection(
|
||
font_collection_loader_.get(),
|
||
collection_key,
|
||
collection_key_size,
|
||
&font_collection
|
||
);
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
collection.SetFontCollection(font_collection);
|
||
}
|
||
}
|
||
}
|
||
|
||
if (FAILED(hr))
|
||
{
|
||
KGE_WARNING_LOG(L"Load font failed with HRESULT of %08X!", hr);
|
||
}
|
||
}
|
||
|
||
void Renderer::CreateFontCollection(FontCollection& collection, Vector<Resource> const& res_arr)
|
||
{
|
||
HRESULT hr = S_OK;
|
||
if (!d2d_res_)
|
||
{
|
||
hr = E_UNEXPECTED;
|
||
}
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
LPVOID collection_key = nullptr;
|
||
UInt32 collection_key_size = 0;
|
||
|
||
hr = res_font_collection_loader_->AddResources(res_arr, &collection_key, &collection_key_size);
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
ComPtr<IDWriteFontCollection> font_collection;
|
||
hr = d2d_res_->GetDWriteFactory()->CreateCustomFontCollection(
|
||
res_font_collection_loader_.get(),
|
||
collection_key,
|
||
collection_key_size,
|
||
&font_collection
|
||
);
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
collection.SetFontCollection(font_collection);
|
||
}
|
||
}
|
||
}
|
||
|
||
if (FAILED(hr))
|
||
{
|
||
KGE_WARNING_LOG(L"Load font failed with HRESULT of %08X!", hr);
|
||
}
|
||
}
|
||
|
||
void Renderer::CreateTextFormat(TextFormat& format, Font const& font)
|
||
{
|
||
HRESULT hr = S_OK;
|
||
if (!d2d_res_)
|
||
{
|
||
hr = E_UNEXPECTED;
|
||
}
|
||
|
||
ComPtr<IDWriteTextFormat> output;
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
hr = d2d_res_->CreateTextFormat(output, font);
|
||
}
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
format.SetTextFormat(output);
|
||
}
|
||
|
||
ThrowIfFailed(hr);
|
||
}
|
||
|
||
void Renderer::CreateTextLayout(TextLayout& layout, String const& text, TextFormat const& format)
|
||
{
|
||
HRESULT hr = S_OK;
|
||
if (!d2d_res_)
|
||
{
|
||
hr = E_UNEXPECTED;
|
||
}
|
||
|
||
ComPtr<IDWriteTextLayout> output;
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
hr = d2d_res_->CreateTextLayout(
|
||
output,
|
||
text,
|
||
format.GetTextFormat()
|
||
);
|
||
}
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
layout.SetTextLayout(output);
|
||
}
|
||
|
||
ThrowIfFailed(hr);
|
||
}
|
||
|
||
void Renderer::CreateLineGeometry(Geometry& geo, Point const& begin_pos, Point const& end_pos)
|
||
{
|
||
HRESULT hr = S_OK;
|
||
if (!d2d_res_)
|
||
{
|
||
hr = E_UNEXPECTED;
|
||
}
|
||
|
||
ComPtr<ID2D1PathGeometry> path_geo;
|
||
ComPtr<ID2D1GeometrySink> path_sink;
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
hr = d2d_res_->GetFactory()->CreatePathGeometry(&path_geo);
|
||
}
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
hr = path_geo->Open(&path_sink);
|
||
}
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
path_sink->BeginFigure(DX::ConvertToPoint2F(begin_pos), D2D1_FIGURE_BEGIN_FILLED);
|
||
path_sink->AddLine(DX::ConvertToPoint2F(end_pos));
|
||
path_sink->EndFigure(D2D1_FIGURE_END_OPEN);
|
||
hr = path_sink->Close();
|
||
}
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
geo.SetGeometry(path_geo);
|
||
}
|
||
|
||
ThrowIfFailed(hr);
|
||
}
|
||
|
||
void Renderer::CreateRectGeometry(Geometry& geo, Rect const& rect)
|
||
{
|
||
HRESULT hr = S_OK;
|
||
if (!d2d_res_)
|
||
{
|
||
hr = E_UNEXPECTED;
|
||
}
|
||
|
||
ComPtr<ID2D1RectangleGeometry> output;
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
hr = d2d_res_->GetFactory()->CreateRectangleGeometry(DX::ConvertToRectF(rect), &output);
|
||
}
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
geo.SetGeometry(output);
|
||
}
|
||
|
||
ThrowIfFailed(hr);
|
||
}
|
||
|
||
void Renderer::CreateRoundedRectGeometry(Geometry& geo, Rect const& rect, Vec2 const& radius)
|
||
{
|
||
HRESULT hr = S_OK;
|
||
if (!d2d_res_)
|
||
{
|
||
hr = E_UNEXPECTED;
|
||
}
|
||
|
||
ComPtr<ID2D1RoundedRectangleGeometry> output;
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
hr = d2d_res_->GetFactory()->CreateRoundedRectangleGeometry(
|
||
D2D1::RoundedRect(
|
||
DX::ConvertToRectF(rect),
|
||
radius.x,
|
||
radius.y
|
||
),
|
||
&output);
|
||
}
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
geo.SetGeometry(output);
|
||
}
|
||
|
||
ThrowIfFailed(hr);
|
||
}
|
||
|
||
void Renderer::CreateEllipseGeometry(Geometry& geo, Point const& center, Vec2 const& radius)
|
||
{
|
||
HRESULT hr = S_OK;
|
||
if (!d2d_res_)
|
||
{
|
||
hr = E_UNEXPECTED;
|
||
}
|
||
|
||
ComPtr<ID2D1EllipseGeometry> output;
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
hr = d2d_res_->GetFactory()->CreateEllipseGeometry(
|
||
D2D1::Ellipse(
|
||
DX::ConvertToPoint2F(center),
|
||
radius.x,
|
||
radius.y
|
||
),
|
||
&output);
|
||
}
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
geo.SetGeometry(output);
|
||
}
|
||
|
||
ThrowIfFailed(hr);
|
||
}
|
||
|
||
void Renderer::CreatePathGeometrySink(GeometrySink& sink)
|
||
{
|
||
HRESULT hr = S_OK;
|
||
if (!d2d_res_)
|
||
{
|
||
hr = E_UNEXPECTED;
|
||
}
|
||
|
||
ComPtr<ID2D1PathGeometry> output;
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
hr = d2d_res_->GetFactory()->CreatePathGeometry(&output);
|
||
}
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
sink.SetPathGeometry(output);
|
||
}
|
||
|
||
ThrowIfFailed(hr);
|
||
}
|
||
|
||
void Renderer::CreateTextureRenderTarget(TextureRenderTarget& render_target)
|
||
{
|
||
HRESULT hr = S_OK;
|
||
if (!d2d_res_)
|
||
{
|
||
hr = E_UNEXPECTED;
|
||
}
|
||
|
||
ComPtr<ID2D1BitmapRenderTarget> output;
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
hr = d2d_res_->GetDeviceContext()->CreateCompatibleRenderTarget(&output);
|
||
}
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
hr = render_target.CreateDeviceResources(output, d2d_res_);
|
||
}
|
||
|
||
ThrowIfFailed(hr);
|
||
}
|
||
|
||
void Renderer::SetVSyncEnabled(bool enabled)
|
||
{
|
||
vsync_ = enabled;
|
||
}
|
||
|
||
void Renderer::SetResolution(Size const& resolution)
|
||
{
|
||
if (resolution_ != resolution)
|
||
{
|
||
resolution_ = resolution;
|
||
UpdateResolution();
|
||
}
|
||
}
|
||
|
||
void Renderer::SetResolutionMode(ResolutionMode mode)
|
||
{
|
||
if (resolution_mode_ != mode)
|
||
{
|
||
resolution_mode_ = mode;
|
||
UpdateResolution();
|
||
}
|
||
}
|
||
|
||
void Renderer::SetClearColor(const Color& color)
|
||
{
|
||
clear_color_ = color;
|
||
}
|
||
|
||
void Renderer::ResizeTarget(UInt32 width, UInt32 height)
|
||
{
|
||
HRESULT hr = S_OK;
|
||
if (!d3d_res_)
|
||
{
|
||
hr = E_UNEXPECTED;
|
||
}
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
output_size_.x = static_cast<Float32>(width);
|
||
output_size_.y = static_cast<Float32>(height);
|
||
hr = d3d_res_->SetLogicalSize(output_size_);
|
||
}
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
UpdateResolution();
|
||
}
|
||
|
||
ThrowIfFailed(hr);
|
||
}
|
||
|
||
void Renderer::UpdateResolution()
|
||
{
|
||
switch (resolution_mode_)
|
||
{
|
||
case ResolutionMode::Fixed:
|
||
{
|
||
SetGlobalTransform(nullptr);
|
||
break;
|
||
}
|
||
|
||
case ResolutionMode::Center:
|
||
{
|
||
Float32 left = math::Ceil((output_size_.x - resolution_.x) / 2);
|
||
Float32 top = math::Ceil((output_size_.y - resolution_.y) / 2);
|
||
SetGlobalTransform(Matrix3x2::Translation(Vec2{ left, top }));
|
||
break;
|
||
}
|
||
|
||
case ResolutionMode::Stretch:
|
||
{
|
||
Float32 scalex = Float32(Int32((output_size_.x / resolution_.x) * 100 + 0.5f)) / 100;
|
||
Float32 scaley = Float32(Int32((output_size_.y / resolution_.y) * 100 + 0.5f)) / 100;
|
||
SetGlobalTransform(Matrix3x2::Scaling(Vec2{ scalex, scaley }));
|
||
break;
|
||
}
|
||
|
||
case ResolutionMode::Adaptive:
|
||
{
|
||
Float32 scalex = Float32(Int32((output_size_.x / resolution_.x) * 100 + 0.5f)) / 100;
|
||
Float32 scaley = Float32(Int32((output_size_.y / resolution_.y) * 100 + 0.5f)) / 100;
|
||
if (scalex > scaley)
|
||
{
|
||
Float32 left = math::Ceil((output_size_.x - resolution_.x * scaley) / 2);
|
||
SetGlobalTransform(Matrix3x2::SRT(Vec2{ left, 0 }, Vec2{ scaley, scaley }, 0));
|
||
}
|
||
else
|
||
{
|
||
Float32 top = math::Ceil((output_size_.y - resolution_.y * scalex) / 2);
|
||
SetGlobalTransform(Matrix3x2::SRT(Vec2{ 0, top }, Vec2{ scalex, scalex }, 0));
|
||
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|