EzUI/sources/Direct2DRender.cpp

#include "Direct2DRender.h"
#include <Shlwapi.h>

#include <GdiPlus.h>
#pragma comment(lib, "gdiplus.lib")

#if USED_DIRECT2D
#define _NOREND_IMAGE_ 
//#define _NOREND_IMAGE_ return;
#pragma comment(lib,"dwrite.lib")
#pragma comment(lib,"d2d1.lib")
#pragma comment(lib,"Windowscodecs.lib")
#undef min
#undef max
namespace ezui {
	ULONG_PTR g_GdiplusToken = NULL;
	namespace D2D {
		ID2D1Factory* g_Direct2dFactory = NULL;
		IDWriteFactory* g_WriteFactory = NULL;
		IWICImagingFactory* g_ImageFactory = NULL;
	}
#define __COLOR_SCALE 0.003921569f
#define __To_D2D_COLOR_F(color) D2D_COLOR_F{FLOAT(color.GetR() * __COLOR_SCALE), FLOAT(color.GetG() * __COLOR_SCALE), FLOAT(color.GetB() * __COLOR_SCALE),FLOAT(color.GetA() * __COLOR_SCALE)}
#define __To_D2D_RectF(rect) D2D_RECT_F{(FLOAT)rect.X,(FLOAT)rect.Y,(FLOAT)rect.GetRight(),(FLOAT)rect.GetBottom() }
#define __To_D2D_PointF(pt)  D2D1_POINT_2F{(FLOAT)pt.X,(FLOAT)pt.Y}

	template<typename Interface>
	inline void SafeRelease(
		Interface** ppInterfaceToRelease)
	{
		if (*ppInterfaceToRelease != NULL)
		{
			(*ppInterfaceToRelease)->Release();
			(*ppInterfaceToRelease) = NULL;
		}
	}

	//TextFormat
	Font::Font(const std::wstring& fontFamily, float fontSize) {
		ASSERT(!(fontSize == 0));
		this->m_fontFamily = fontFamily;
		this->m_fontSize = fontSize;
		D2D::g_WriteFactory->CreateTextFormat(fontFamily.c_str(), NULL, DWRITE_FONT_WEIGHT_NORMAL, DWRITE_FONT_STYLE_NORMAL, DWRITE_FONT_STRETCH_NORMAL, m_fontSize, L"", &m_value);
	}
	Font::~Font() {
		if (m_value && !m_ref) {
			SafeRelease(&m_value);
		}
	}
	float Font::GetFontSize()const {
		return m_fontSize;
	}
	const std::wstring& Font::GetFontFamily()const {
		return m_fontFamily;
	}
	void Font::Copy(const Font& _copy) {
		((Font&)(_copy)).m_ref = true;
		this->m_value = _copy.Get();
		this->m_fontFamily = _copy.GetFontFamily();
		this->m_fontSize = _copy.GetFontSize();
	}
	IDWriteTextFormat* Font::Get() const {
		return m_value;
	}
	Font::Font(const Font& rightValue) {
		Copy(rightValue);
	}
	bool Font::operator==(const Font& _right) {
		if (_right.GetFontFamily() == this->GetFontFamily() && (std::fabs(_right.GetFontSize() - this->GetFontSize()) < EZUI_FLOAT_EPSILON)) {
			return true;
		}
		return false;
	}
	void TextLayout::GetMetrics()
	{
		if (m_textLayout) {
			m_textLayout->GetMetrics(&m_textMetrics);
		}
	}
	//TextLayout
	TextLayout::TextLayout(const std::wstring& text, const Font& font, const SizeF& maxSize, TextAlign textAlign) {
		this->m_unicodeSize = text.size();
		this->m_fontSize = font.GetFontSize();
		this->m_fontFamily = font.GetFontFamily();
		D2D::g_WriteFactory->CreateTextLayout(text.c_str(), text.size(), font.Get(), maxSize.Width, maxSize.Height, &m_textLayout);
		if (m_textLayout == NULL)return;
		SetTextAlign(textAlign);
	}
	IDWriteTextLayout* TextLayout::Get() const {
		return m_textLayout;
	}
	Point TextLayout::HitTestPoint(const Point& pt, int* _textPos, BOOL* _isTrailingHit, int* fontHeight) {
		int& textPos = *_textPos;
		BOOL& isTrailingHit = *_isTrailingHit;
		DWRITE_HIT_TEST_METRICS hitTestMetrics;
		BOOL isInside;
		{
			FLOAT x = (FLOAT)pt.X, y = (FLOAT)pt.Y;
			m_textLayout->HitTestPoint(
				(FLOAT)x,
				(FLOAT)y,
				&isTrailingHit,
				&isInside,
				&hitTestMetrics
			);
		}
		int posX = (int)(hitTestMetrics.left + 0.5);
		if (isTrailingHit) {//判断前侧还是尾侧
			posX += (int)(hitTestMetrics.width + 0.5);
		}
		*fontHeight = (int)(hitTestMetrics.height + 0.5);
		textPos = hitTestMetrics.textPosition;
		return Point{ posX,(int)(hitTestMetrics.top + 0.5) };//返回光标所在的位置
	}

	void TextLayout::HitTestPoint(const Point& pt, HitTestMetrics* outHitTestMetrics) {
		BOOL isTrailingHit;
		DWRITE_HIT_TEST_METRICS hitTestMetrics;
		BOOL isInside;
		{
			FLOAT x = (FLOAT)pt.X, y = (FLOAT)pt.Y;
			m_textLayout->HitTestPoint(
				(FLOAT)x,
				(FLOAT)y,
				&isTrailingHit,
				&isInside,
				&hitTestMetrics
			);
		}
		outHitTestMetrics->Length = hitTestMetrics.length;
		outHitTestMetrics->TextPos = hitTestMetrics.textPosition;
		outHitTestMetrics->IsTrailingHit = isTrailingHit;
		outHitTestMetrics->FontBox.X = hitTestMetrics.left;
		outHitTestMetrics->FontBox.Y = hitTestMetrics.top;
		outHitTestMetrics->FontBox.Width = hitTestMetrics.width;
		outHitTestMetrics->FontBox.Height = hitTestMetrics.height;
	}

	Point TextLayout::HitTestTextPosition(int textPos, BOOL isTrailingHit) {
		if (m_textLayout == NULL)return Point{ 0,0 };
		DWRITE_HIT_TEST_METRICS hitTestMetrics;
		FLOAT X, Y;
		m_textLayout->HitTestTextPosition(textPos, isTrailingHit, &X, &Y, &hitTestMetrics);
		return Point((int)(X + 0.5), (int)(Y + 0.5));
	}
	const std::wstring& TextLayout::GetFontFamily()
	{
		return this->m_fontFamily;
	}
	Size TextLayout::GetFontBox() {
		this->GetMetrics();
		FLOAT width = m_textMetrics.widthIncludingTrailingWhitespace;
		FLOAT height = m_textMetrics.height;
		return  Size{ (int)(width + 1) ,(int)(height + 1) };//加1是为了向上取整
	}
	float TextLayout::GetFontSize()
	{
		return this->m_fontSize;
	}
	int TextLayout::Width() {
		this->GetMetrics();
		FLOAT width = m_textMetrics.widthIncludingTrailingWhitespace;
		return (int)(width + 1);
	}
	int TextLayout::Height() {
		this->GetMetrics();
		FLOAT width = m_textMetrics.height;
		return (width + 1);
	}
	int TextLayout::GetFontHeight() {
		this->GetMetrics();
		FLOAT height = m_textMetrics.height;
		return  ((height / m_textMetrics.lineCount) + 0.5);
	}
	int TextLayout::GetLineCount() {
		this->GetMetrics();
		return m_textMetrics.lineCount;
	}

#undef min
#undef max
	const std::vector<RectF>& TextLayout::GetLineRects() {
		//如果unicode个数为0 且获取过m_lineRects 则直接返回不执行获取操作
		if (!m_textLayout || m_unicodeSize == 0 || !m_lineRects.empty()) {
			return m_lineRects;
		}
		UINT lineCount = GetLineCount();
		//获取每行 metrics
		std::vector<DWRITE_LINE_METRICS> lineMetrics(lineCount);
		auto hr = m_textLayout->GetLineMetrics(lineMetrics.data(), lineCount, &lineCount);
		if (FAILED(hr)) {
			return m_lineRects;
		}
		//遍历每一行，计算对应矩形
		UINT32 textPos = 0;
		for (UINT32 i = 0; i < lineCount; i++) {
			auto& lm = lineMetrics[i];
			if (lm.length == 0) { // 空行
				textPos += lm.length;
				continue;
			}
			//给一个足够大的 buffer，存放 hit test 的矩形
			std::vector<DWRITE_HIT_TEST_METRICS> metrics(lm.length);
			UINT32 actualCount = 0;

			hr = m_textLayout->HitTestTextRange(
				textPos, lm.length, // 这一行的字符范围
				0.0f, 0.0f,         // offsetX, offsetY
				metrics.data(), (UINT32)metrics.size(),
				&actualCount
			);

			if (SUCCEEDED(hr) && actualCount > 0) {
				float minX = metrics[0].left;
				float maxX = metrics[0].left + metrics[0].width;
				float top = metrics[0].top;
				float bottom = top + metrics[0].height;

				for (UINT32 j = 1; j < actualCount; j++) {
					auto& m = metrics[j];
					minX = std::min(minX, m.left);
					maxX = std::max(maxX, m.left + m.width);
					top = std::min(top, m.top);
					bottom = std::max(bottom, m.top + m.height);
				}
				m_lineRects.push_back(RectF(minX, top, maxX - minX, bottom - top));
			}
			textPos += lm.length; //下一行的起始字符
		}
		return m_lineRects;
	}

	void TextLayout::SetTextAlign(TextAlign textAlign) {
#define __Top DWRITE_PARAGRAPH_ALIGNMENT_NEAR
#define	__Bottom DWRITE_PARAGRAPH_ALIGNMENT_FAR
#define	__Left DWRITE_TEXT_ALIGNMENT_LEADING
#define	__Right DWRITE_TEXT_ALIGNMENT_TRAILING
#define	__Middle DWRITE_PARAGRAPH_ALIGNMENT_CENTER
#define __Center DWRITE_TEXT_ALIGNMENT_CENTER
		if (m_textLayout == NULL)return;
		//垂直对其方式
		if (((int)textAlign & (int)VAlign::Top) == (int)VAlign::Top) {
			m_textLayout->SetParagraphAlignment(__Top);
		}
		if (((int)textAlign & (int)VAlign::Mid) == (int)VAlign::Mid) {
			m_textLayout->SetParagraphAlignment(__Middle);
		}
		if (((int)textAlign & (int)VAlign::Bottom) == (int)VAlign::Bottom) {
			m_textLayout->SetParagraphAlignment(__Bottom);
		}
		//水平对其方式
		if (((int)textAlign & (int)HAlign::Left) == (int)HAlign::Left) {
			m_textLayout->SetTextAlignment(__Left);
		}
		if (((int)textAlign & (int)HAlign::Center) == (int)HAlign::Center) {
			m_textLayout->SetTextAlignment(__Center);
		}
		if (((int)textAlign & (int)HAlign::Right) == (int)HAlign::Right) {
			m_textLayout->SetTextAlignment(__Right);
		}
#undef __Top 
#undef __Bottom 
#undef __Left 
#undef __Right 
#undef __Middle 
#undef __Center
	}
	void TextLayout::SetUnderline(int pos, int count)
	{
		if (count > 0) {
			m_textLayout->SetUnderline(TRUE, { (UINT32)pos,(UINT32)count });
		}
	}
	TextLayout::~TextLayout() {
		if (m_textLayout) {
			SafeRelease(&m_textLayout);
		}
	}
	//DXImage
	void DXImage::DecodeOfRender(ID2D1RenderTarget* render) {
		HRESULT hr = 0;
		if (m_d2dBitmap != NULL) {
			if (m_d2dBitmap) {
				SafeRelease(&m_d2dBitmap);
			}
		}
		if (m_fmtcovter) {
			hr = render->CreateBitmapFromWicBitmap(m_fmtcovter, 0, &m_d2dBitmap);
		}
		if (m_bitMap) {
			hr = render->CreateBitmapFromWicBitmap(m_bitMap, &m_d2dBitmap);
		}
	}
	int DXImage::Width() {
		return m_width;
	}
	int DXImage::Height() {
		return m_height;
	}
	void DXImage::CreateFormStream(IStream* istram) {
		HRESULT imgCreate = S_OK;
		if (D2D::g_ImageFactory) {
			imgCreate = D2D::g_ImageFactory->CreateDecoderFromStream(istram, NULL, WICDecodeMetadataCacheOnDemand, &m_bitmapdecoder);//
		}
		if (m_bitmapdecoder) {
			D2D::g_ImageFactory->CreateFormatConverter(&m_fmtcovter);
			m_bitmapdecoder->GetFrame(0, &m_pframe);
			m_fmtcovter->Initialize(m_pframe, GUID_WICPixelFormat32bppPBGRA, WICBitmapDitherTypeNone, NULL, 0.0f, WICBitmapPaletteTypeCustom);
			UINT width, height;
			m_pframe->GetSize(&width, &height);
			this->m_width = width;
			this->m_height = height;
			Init();
		}
	}
	void DXImage::CreateFromFile(const std::wstring& filew)
	{
		HRESULT ret = S_OK;
		if (D2D::g_ImageFactory) {
			ret = D2D::g_ImageFactory->CreateDecoderFromFilename(filew.c_str(), NULL, GENERIC_READ, WICDecodeMetadataCacheOnDemand, &m_bitmapdecoder);//
		}
		if (m_bitmapdecoder) {
			ret = D2D::g_ImageFactory->CreateFormatConverter(&m_fmtcovter);
			ret = m_bitmapdecoder->GetFrame(0, &m_pframe);
			ret = m_fmtcovter->Initialize(m_pframe, GUID_WICPixelFormat32bppPBGRA, WICBitmapDitherTypeNone, NULL, 0.0f, WICBitmapPaletteTypeCustom);
			UINT width, height;
			ret = m_pframe->GetSize(&width, &height);
			this->m_width = width;
			this->m_height = height;
			Init();
		}
	}

	// 获取 GIF 帧位置
	WICRect GetFrameRect(IWICMetadataQueryReader* metaReader) {
		WICRect rect = { 0,0,0,0 };
		PROPVARIANT pv;
		PropVariantInit(&pv);

		if (SUCCEEDED(metaReader->GetMetadataByName(L"/imgdesc/Left", &pv))) {
			rect.X = pv.uiVal;
		}
		PropVariantClear(&pv);

		if (SUCCEEDED(metaReader->GetMetadataByName(L"/imgdesc/Top", &pv)))
		{
			rect.Y = pv.uiVal;
		}
		PropVariantClear(&pv);

		if (SUCCEEDED(metaReader->GetMetadataByName(L"/imgdesc/Width", &pv)))
		{
			rect.Width = pv.uiVal;
		}
		PropVariantClear(&pv);

		if (SUCCEEDED(metaReader->GetMetadataByName(L"/imgdesc/Height", &pv)))
		{
			rect.Height = pv.uiVal;
		}
		PropVariantClear(&pv);

		return rect;
	}

	// 拷贝整个位图
	void CopyBitmap(IWICBitmap* src, IWICBitmap* dst) {
		if (!src || !dst) return;

		UINT w = 0, h = 0;
		src->GetSize(&w, &h);
		WICRect rect = { 0,0,(INT)w,(INT)h };

		IWICBitmapLock* lockSrc = NULL;
		IWICBitmapLock* lockDst = NULL;

		if (SUCCEEDED(src->Lock(&rect, WICBitmapLockRead, &lockSrc)) &&
			SUCCEEDED(dst->Lock(&rect, WICBitmapLockWrite, &lockDst)))
		{
			UINT cbBufferSrc = 0, cbBufferDst = 0;
			BYTE* pSrc = NULL;
			BYTE* pDst = NULL;
			lockSrc->GetDataPointer(&cbBufferSrc, &pSrc);
			lockDst->GetDataPointer(&cbBufferDst, &pDst);

			memcpy(pDst, pSrc, cbBufferSrc);
		}

		if (lockSrc) SafeRelease(&lockSrc);
		if (lockDst) SafeRelease(&lockDst);
	}

	// 清除矩形区域（透明）
	void ClearRegion(IWICBitmap* bmp, const WICRect& rect) {
		if (!bmp) return;

		IWICBitmapLock* lock = NULL;
		if (SUCCEEDED(bmp->Lock(&rect, WICBitmapLockWrite, &lock)))
		{
			UINT cbBuffer = 0;
			BYTE* pData = NULL;
			lock->GetDataPointer(&cbBuffer, &pData);
			memset(pData, 0, cbBuffer); // 全部置 0（透明）
		}
		SafeRelease(&lock);
	}
	void CopyFrameToCanvas(IWICBitmapSource* frame, IWICBitmap* canvas, UINT CanvasWidth, UINT CanvasHeight, const WICRect& frameRect)
	{
		if (!frame || !canvas) return;

		// 锁定整个画布
		WICRect fullRect{ 0, 0, (INT)CanvasWidth, (INT)CanvasHeight };
		IWICBitmapLock* lock = NULL;
		if (FAILED(canvas->Lock(&fullRect, WICBitmapLockWrite, &lock))) return;

		UINT cbBuffer = 0;
		BYTE* pDst = NULL;
		lock->GetDataPointer(&cbBuffer, &pDst);

		UINT canvasStride = CanvasWidth * 4;
		UINT frameStride = frameRect.Width * 4;
		UINT frameBufferSize = frameStride * frameRect.Height;
		BYTE* tempBuffer = new BYTE[frameBufferSize];

		WICRect copyRect = { 0, 0, frameRect.Width, frameRect.Height };
		HRESULT hr = frame->CopyPixels(&copyRect, frameStride, frameBufferSize, tempBuffer);
		if (FAILED(hr)) {
			delete[] tempBuffer;
			SafeRelease(&lock);
			return;
		}

		// 复制像素到画布的对应偏移位置
		for (UINT y = 0; y < frameRect.Height; y++) {
			BYTE* srcLine = tempBuffer + y * frameStride;
			BYTE* dstLine = pDst + (frameRect.Y + y) * canvasStride + frameRect.X * 4;

			for (UINT x = 0; x < frameRect.Width; x++) {
				BYTE* srcPx = srcLine + x * 4;
				BYTE* dstPx = dstLine + x * 4;

				BYTE srcA = srcPx[3];
				if (srcA != 0) {
					dstPx[0] = srcPx[0];
					dstPx[1] = srcPx[1];
					dstPx[2] = srcPx[2];
					dstPx[3] = srcPx[3];
				}
			}
		}

		//释放
		delete[] tempBuffer;
		SafeRelease(&lock);
	}

	void DXImage::Init()
	{
		m_framePos = 0;
		m_frames.clear();

		if (!m_bitmapdecoder) return;

		UINT fCount = 0;
		m_bitmapdecoder->GetFrameCount(&fCount);
		m_frameCount = fCount;

		if (fCount <= 1) {
			return;
		}
		if (m_fmtcovter) {
			//如果是gif那就不需要m_fmtcovter 因为会把解析完毕的每一帧存储起来直接用
			SafeRelease(&m_fmtcovter);
		}

		UINT width = Width();
		UINT height = Height();

		// 创建全尺寸画布
		IWICBitmap* canvas = NULL;
		D2D::g_ImageFactory->CreateBitmap(
			width, height,
			GUID_WICPixelFormat32bppPBGRA,
			WICBitmapCacheOnLoad,
			&canvas);

		// 备份画布（用于 disposal=3）
		IWICBitmap* prevCanvas = NULL;
		D2D::g_ImageFactory->CreateBitmap(
			width, height,
			GUID_WICPixelFormat32bppPBGRA,
			WICBitmapCacheOnLoad,
			&prevCanvas);

		for (UINT i = 0; i < fCount; i++)
		{
			IWICBitmapFrameDecode* srcFrame = NULL;
			m_bitmapdecoder->GetFrame(i, &srcFrame);

			// 元数据读取器
			IWICMetadataQueryReader* metaReader = NULL;
			srcFrame->GetMetadataQueryReader(&metaReader);

			// 延时
			UINT delayMs = 100;
			PROPVARIANT pv;
			PropVariantInit(&pv);
			if (SUCCEEDED(metaReader->GetMetadataByName(L"/grctlext/Delay", &pv)))
			{
				delayMs = pv.uiVal * 10; // 单位 1/100 秒
			}
			PropVariantClear(&pv);

			// Disposal
			UINT disposal = 0;
			if (SUCCEEDED(metaReader->GetMetadataByName(L"/grctlext/Disposal", &pv)))
			{
				disposal = pv.uiVal;
			}
			PropVariantClear(&pv);

			// Disposal=3 保存备份
			if (disposal == 3) {
				CopyBitmap(canvas, prevCanvas);
			}

			// Disposal=2 清区域
			if (disposal == 2 && i > 0)
			{
				WICRect rect = GetFrameRect(metaReader);
				ClearRegion(canvas, rect);
			}
			else if (disposal == 3 && i > 0)
			{
				CopyBitmap(prevCanvas, canvas);
			}

			// 转换帧格式
			IWICFormatConverter* converter = NULL;
			D2D::g_ImageFactory->CreateFormatConverter(&converter);
			converter->Initialize(srcFrame, GUID_WICPixelFormat32bppPBGRA, WICBitmapDitherTypeNone, NULL, 0.f, WICBitmapPaletteTypeCustom);

			// 帧矩形
			WICRect rect = GetFrameRect(metaReader);

			// 绘制到 canvas
			CopyFrameToCanvas(converter, canvas, width, height, rect);

			// 存一份当前画布的完整副本
			IWICBitmap* frameCopy = NULL;
			D2D::g_ImageFactory->CreateBitmapFromSource(canvas, WICBitmapCacheOnLoad, &frameCopy);
			GifFrame gf = { frameCopy, delayMs };
			m_frames.push_back(gf);

			// 释放临时对象
			SafeRelease(&converter);
			SafeRelease(&metaReader);
			SafeRelease(&srcFrame);

		}
		// 释放画布
		SafeRelease(&canvas);
		SafeRelease(&prevCanvas);
		//读取第一帧
		this->NextFrame();
	}

	WORD DXImage::NextFrame() {
		if (m_frames.empty()) {
			return 0; // 没有帧
		}
		if (m_framePos >= m_frames.size()) {
			m_framePos = 0;
		}
		this->m_bitMap = m_frames[m_framePos].wicBitmap;
		UINT delayMs = m_frames[m_framePos].delay;
		// 这里不需要释放和创建格式转换器了，播放时再转 D2D 位图
		// 只移动索引
		m_framePos++;
		return (WORD)delayMs;
	}
	DXImage* DXImage::Clone()
	{
		UINT width, height;
		m_fmtcovter->GetSize(&width, &height); // 获取位图源的宽度和高度
		//暂时不做clone函数
		return NULL;
	}
	DXImage::DXImage(HBITMAP hBitmap) {
		if (D2D::g_ImageFactory) {
			//WICBitmapUsePremultipliedAlpha:传入的图像颜色值已经与 Alpha 通道预乘
			D2D::g_ImageFactory->CreateBitmapFromHBITMAP(hBitmap, NULL, WICBitmapUsePremultipliedAlpha, &m_bitMap);
			UINT width, height;
			m_bitMap->GetSize(&width, &height);
			this->m_width = width;
			this->m_height = height;
			Init();
		}
	}
	DXImage::DXImage(const std::wstring& file) {
		CreateFromFile(file);
	}
	DXImage::DXImage(int width, int height)
	{
		this->m_width = width;
		this->m_height = height;
		ASSERT(!(width <= 0 || height <= 0));
		HRESULT hr = D2D::g_ImageFactory->CreateBitmap((UINT)width, (UINT)height, GUID_WICPixelFormat32bppPBGRA, WICBitmapCacheOnDemand, &m_bitMap);
	}
	DXImage::DXImage(const void* data, size_t imgSize)
	{
		ASSERT(data);
		ASSERT(imgSize);
		IStream* stream = SHCreateMemStream((BYTE*)data, imgSize);
		if (stream) {
			this->CreateFormStream(stream);
			SafeRelease(&stream);
		}
	}
	ID2D1Bitmap* DXImage::Get()
	{
		return m_d2dBitmap;
	}
	IWICBitmap* DXImage::GetIWICBitmap()
	{
		return m_bitMap;
	}
	DXImage::DXImage(IStream* istram) {
		CreateFormStream(istram);
	}
	DXImage::~DXImage()
	{
		if (m_d2dBitmap) {
			SafeRelease(&m_d2dBitmap);
		}
		if (m_bitmapdecoder) {
			SafeRelease(&m_bitmapdecoder);
		}
		if (m_pframe) {
			SafeRelease(&m_pframe);
		}
		if (m_fmtcovter) {
			SafeRelease(&m_fmtcovter);
		}
		if (m_bitMap) {
			SafeRelease(&m_bitMap);
		}
		for (auto& it : m_frames) {
			SafeRelease(&it.wicBitmap);
		}
	}

	void Geometry::Combine(Geometry& out, const Geometry& a, const Geometry& b, D2D1_COMBINE_MODE COMBINE_MODE)
	{
		ID2D1PathGeometry* outPathGeometry = NULL;
		D2D::g_Direct2dFactory->CreatePathGeometry(&outPathGeometry);
		ID2D1GeometrySink* geometrySink = NULL;
		outPathGeometry->Open(&geometrySink);
		HRESULT ret = a.m_rgn->CombineWithGeometry(b.m_rgn, COMBINE_MODE, NULL, geometrySink);
		geometrySink->Close();
		if (out.m_rgn) {
			SafeRelease(&out.m_rgn);
		}
		out.m_rgn = outPathGeometry;
		SafeRelease(&geometrySink);
	}

	void RectangleGeometry::Create(float x, float y, float width, float height, float _radius)
	{
		if (_radius > 0) {
			float radius = GetMaxRadius(width, height, _radius);
			D2D1_ROUNDED_RECT rectF{ x,y,(x + width),(y + height) ,radius ,radius };
			D2D::g_Direct2dFactory->CreateRoundedRectangleGeometry(rectF, (ID2D1RoundedRectangleGeometry**)&m_rgn);
		}
		else {
			D2D_RECT_F rectF{ x,y,(x + width),(y + height) };
			D2D::g_Direct2dFactory->CreateRectangleGeometry(rectF, (ID2D1RectangleGeometry**)&m_rgn);
		}
	}
	RectangleGeometry::RectangleGeometry(float x, float y, float width, float height, float _radius) {
		Create(x, y, width, height, _radius);
	}
	RectangleGeometry::RectangleGeometry(const RectF& _rect, float _radius)
	{
		float x = _rect.X, y = _rect.Y, width = _rect.Width, height = _rect.Height;
		Create(x, y, width, height, _radius);
	}
	RectangleGeometry::RectangleGeometry(const RectF& _rect, float topLeftRadius, float topRightRadius, float bottomRightRadius, float bottomLeftRadius)
	{
		ID2D1PathGeometry* pPathGeometry = NULL;
		D2D1_RECT_F rect = __To_D2D_RectF(_rect);
		D2D::g_Direct2dFactory->CreatePathGeometry(&pPathGeometry);
		topLeftRadius = GetMaxRadius(_rect.Width, _rect.Height, topLeftRadius);
		topRightRadius = GetMaxRadius(_rect.Width, _rect.Height, topRightRadius);
		bottomRightRadius = GetMaxRadius(_rect.Width, _rect.Height, bottomRightRadius);
		bottomLeftRadius = GetMaxRadius(_rect.Width, _rect.Height, bottomLeftRadius);
		// 打开路径几何图形的几何接口
		ID2D1GeometrySink* pSink;
		pPathGeometry->Open(&pSink);
		// 开始绘制路径
		pSink->BeginFigure(D2D1::Point2F(rect.left, rect.top + topLeftRadius), D2D1_FIGURE_BEGIN_FILLED);
		// 添加弧线段到左上角
		pSink->AddArc(
			D2D1::ArcSegment(
				D2D1::Point2F(rect.left + topLeftRadius, rect.top),
				D2D1::SizeF(topLeftRadius, topLeftRadius),
				0.0f,
				D2D1_SWEEP_DIRECTION_CLOCKWISE,
				D2D1_ARC_SIZE_SMALL
			)
		);
		// 添加弧线段到右上角
		pSink->AddLine(D2D1::Point2F(rect.right - topRightRadius, rect.top));
		pSink->AddArc(
			D2D1::ArcSegment(
				D2D1::Point2F(rect.right, rect.top + topRightRadius),
				D2D1::SizeF(topRightRadius, topRightRadius),
				0.0f,
				D2D1_SWEEP_DIRECTION_CLOCKWISE,
				D2D1_ARC_SIZE_SMALL
			)
		);
		// 添加弧线段到右下角
		pSink->AddLine(D2D1::Point2F(rect.right, rect.bottom - bottomRightRadius));
		pSink->AddArc(
			D2D1::ArcSegment(
				D2D1::Point2F(rect.right - bottomRightRadius, rect.bottom),
				D2D1::SizeF(bottomRightRadius, bottomRightRadius),
				0.0f,
				D2D1_SWEEP_DIRECTION_CLOCKWISE,
				D2D1_ARC_SIZE_SMALL
			)
		);
		// 添加弧线段到左下角
		pSink->AddLine(D2D1::Point2F(rect.left + bottomLeftRadius, rect.bottom));
		pSink->AddArc(
			D2D1::ArcSegment(
				D2D1::Point2F(rect.left, rect.bottom - bottomLeftRadius),
				D2D1::SizeF(bottomLeftRadius, bottomLeftRadius),
				0.0f,
				D2D1_SWEEP_DIRECTION_CLOCKWISE,
				D2D1_ARC_SIZE_SMALL
			)
		);
		// 结束路径
		pSink->EndFigure(D2D1_FIGURE_END_CLOSED);
		pSink->Close();
		SafeRelease(&pSink);
		this->m_rgn = pPathGeometry;
	}

	Geometry::Geometry() {
	}

	void Geometry::AddArc(const PointF& endPoint, float radius) {
		m_pSink->AddArc(
			D2D1::ArcSegment(
				D2D1::Point2F(endPoint.X, endPoint.Y),
				D2D1::SizeF(radius, radius),
				0.0f,
				D2D1_SWEEP_DIRECTION_CLOCKWISE,
				D2D1_ARC_SIZE_SMALL
			)
		);
	}

	void Geometry::AddAcr(const D2D1_ARC_SEGMENT& arc)
	{
		m_pSink->AddArc(arc);
	}

	void Geometry::AddLine(const PointF& endPoint) {
		D2D1_POINT_2F p{ endPoint.X, endPoint.Y };
		m_pSink->AddLine(p);
	}
	void Geometry::BeginFigure(const PointF& startPoint, D2D1_FIGURE_BEGIN figureBegin) {
		ID2D1PathGeometry* path;
		D2D::g_Direct2dFactory->CreatePathGeometry(&path);
		path->Open(&m_pSink);
		m_pSink->BeginFigure(__To_D2D_PointF(startPoint), figureBegin);
		m_rgn = path;
	}
	void Geometry::CloseFigure(D2D1_FIGURE_END figureEnd) {
		m_pSink->EndFigure(figureEnd);
		m_pSink->Close(); // 完成 Path 定义
	}

	Geometry::~Geometry() {
		if (m_pSink) {
			SafeRelease(&m_pSink);
		}
		if (m_rgn) {
			SafeRelease(&m_rgn);

		}
	}
	ID2D1Geometry* Geometry::Get() const {
		return m_rgn;
	}


	PieGeometry::PieGeometry(const RectF& rectF, float startAngle, float endAngle)
	{
		auto rect = __To_D2D_RectF(rectF);
		// 1. 计算圆心和半径
		D2D1_POINT_2F center = {
			(rect.left + rect.right) / 2.0f,
			(rect.top + rect.bottom) / 2.0f
		};

		float radiusX = (rect.right - rect.left) / 2.0f;
		float radiusY = (rect.bottom - rect.top) / 2.0f;

		bool isFullCircle = fabsf(endAngle - startAngle) >= 359.999f;
		if (isFullCircle) {
			// 方法2：直接使用椭圆几何（更高效）
			ID2D1EllipseGeometry* pEllipse = NULL;
			D2D1_ELLIPSE ellipse{ center, radiusX, radiusY };
			D2D::g_Direct2dFactory->CreateEllipseGeometry(&ellipse, &pEllipse);
			//赋值
			this->m_rgn = (ID2D1Geometry*)pEllipse;
		}
		else {

			// 2. 角度处理（转换为弧度）
			float startRad = startAngle * (3.1415926f / 180.0f);
			float endRad = endAngle * (3.1415926f / 180.0f);

			// 3. 创建路径几何
			ID2D1PathGeometry* pGeometry = NULL;
			D2D::g_Direct2dFactory->CreatePathGeometry(&pGeometry);

			ID2D1GeometrySink* pSink = NULL;
			pGeometry->Open(&pSink);
			// 4. 计算弧线起点和终点
			D2D1_POINT_2F startPoint = {
				center.x + radiusX * cosf(startRad),
				center.y + radiusY * sinf(startRad)
			};
			D2D1_POINT_2F endPoint = {
				center.x + radiusX * cosf(endRad),
				center.y + radiusY * sinf(endRad)
			};

			// 5. 构造扇形路径
			pSink->BeginFigure(center, D2D1_FIGURE_BEGIN_FILLED);
			pSink->AddLine(startPoint);

			D2D1_ARC_SEGMENT arc{
				endPoint,
				D2D1::SizeF(radiusX, radiusY),
				0.0f,
				(endRad > startRad) ? D2D1_SWEEP_DIRECTION_CLOCKWISE : D2D1_SWEEP_DIRECTION_COUNTER_CLOCKWISE,
				(fabsf(endRad - startRad) <= 3.1415926f) ? D2D1_ARC_SIZE_SMALL : D2D1_ARC_SIZE_LARGE
			};
			pSink->AddArc(arc);
			pSink->AddLine(center);
			pSink->EndFigure(D2D1_FIGURE_END_CLOSED);
			//释放
			pSink->Close();
			SafeRelease(&pSink);
			//赋值
			this->m_rgn = pGeometry;
		}
	}
};

namespace ezui {
	void RenderInitialize()
	{
		HRESULT hr = S_OK;
		// Create a Direct2D factory.
		if (D2D::g_Direct2dFactory == NULL) {
			hr = ::D2D1CreateFactory(D2D1_FACTORY_TYPE_MULTI_THREADED, &D2D::g_Direct2dFactory);
			if (!D2D::g_Direct2dFactory) {
				::MessageBoxW(NULL, L"Failed to create ID2D1Factory", L"Error", MB_ICONSTOP);
			}
			else {
				D2D1_RENDER_TARGET_PROPERTIES defaultOption = D2D1::RenderTargetProperties(
					D2D1_RENDER_TARGET_TYPE_DEFAULT,
					D2D1::PixelFormat(
						DXGI_FORMAT_B8G8R8A8_UNORM,
						D2D1_ALPHA_MODE_PREMULTIPLIED),
					0,
					0,
					D2D1_RENDER_TARGET_USAGE_NONE,
					D2D1_FEATURE_LEVEL_DEFAULT
				);
				//初始化一下d2d让第一次启动窗口快一点
				ID2D1DCRenderTarget* initRender = NULL;
				hr = D2D::g_Direct2dFactory->CreateDCRenderTarget(&defaultOption, (ID2D1DCRenderTarget**)&initRender);
				SafeRelease(&initRender);
			}
		}
		if (D2D::g_WriteFactory == NULL) {
			hr = DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, __uuidof(IDWriteFactory), reinterpret_cast<IUnknown**>(&D2D::g_WriteFactory));
			if (!D2D::g_WriteFactory) {
				::MessageBoxW(NULL, L"Failed to create IDWriteFactory", L"Error", MB_ICONSTOP);
			}
		}
		if (D2D::g_ImageFactory == NULL) {
			_GUID imageFactoryOld{ 0xcacaf262, 0x9370, 0x4615, 0xa1, 0x3b, 0x9f, 0x55, 0x39, 0xda, 0x4c, 0xa };//xp  win7 旧版
			_GUID WICImagingFactoryId = CLSID_WICImagingFactory;//当前平台
		ImagingFactoryInit:
			hr = CoCreateInstance(WICImagingFactoryId, NULL, CLSCTX_INPROC_SERVER, __uuidof(IWICImagingFactory), (LPVOID*)&D2D::g_ImageFactory);
			if (hr != S_OK) {
				//if (hr == 0x800401F0) {//未初始化com 自己在全局初始化一下就好了 (自己控制初始化时机)
				//	::CoInitialize(NULL);
				//	goto ImagingFactory;
				//}
				if (hr == 0x80040154) {//没有注册类 不用win7的sdk生成的程序在下win7系统上运行会出现此错误
					WICImagingFactoryId = imageFactoryOld;
					goto ImagingFactoryInit;
				}
				CHAR buf[256]{ 0 };
				sprintf_s(buf, "Code 0x%08X", hr);
				::MessageBoxA(NULL, buf, "Failed to create IWICImagingFactory", MB_ICONSTOP);
			}
		}

		if (g_GdiplusToken == NULL) {
			//初始化GDI+
			Gdiplus::GdiplusStartupInput gdiplusStartupInput;
			Gdiplus::GdiplusStartup(&g_GdiplusToken, &gdiplusStartupInput, NULL);
		}
	}
	void RenderUnInitialize()
	{
		if (D2D::g_Direct2dFactory) {
			SafeRelease(&D2D::g_Direct2dFactory);
		}
		if (D2D::g_WriteFactory) {
			SafeRelease(&D2D::g_WriteFactory);
		}
		if (D2D::g_ImageFactory) {
			SafeRelease(&D2D::g_ImageFactory);
		}
		//释放GDI+
		if (g_GdiplusToken) {
			Gdiplus::GdiplusShutdown(g_GdiplusToken);
			g_GdiplusToken = NULL;
		}
	}
	float GetMaxRadius(float width, float height, float _radius)
	{
		float radius = _radius;//半径
		float diameter = radius * 2;//直径
		if (width > height || (std::fabs(width - height) < EZUI_FLOAT_EPSILON)) {
			if (diameter > height) {
				radius = height / 2.0f;
			}
		}
		else if (height > width) {
			if (diameter > width) {
				radius = width / 2.0f;
			}
		}
		return  radius;
	}
	DXRender::DXRender(HDC dc, int x, int y, int width, int height) {
		D2D1_RENDER_TARGET_PROPERTIES defaultOption = D2D1::RenderTargetProperties(
			D2D1_RENDER_TARGET_TYPE_DEFAULT,
			D2D1::PixelFormat(
				DXGI_FORMAT_B8G8R8A8_UNORM,
				D2D1_ALPHA_MODE_PREMULTIPLIED),//表示三通道的值已经是预乘了a通之后的数值
			0,
			0,
			D2D1_RENDER_TARGET_USAGE_NONE,
			D2D1_FEATURE_LEVEL_DEFAULT
		);
		HRESULT	hr = D2D::g_Direct2dFactory->CreateDCRenderTarget(&defaultOption, (ID2D1DCRenderTarget**)&m_render);
		RECT rc{ x,y,x + width ,y + height };
		((ID2D1DCRenderTarget*)m_render)->BindDC(dc, &rc);
		m_render->BeginDraw();
	}

	DXRender::DXRender(DXImage* dxImage) {
		D2D1_RENDER_TARGET_PROPERTIES defaultOption = D2D1::RenderTargetProperties(
			D2D1_RENDER_TARGET_TYPE_DEFAULT,
			D2D1::PixelFormat(),
			0,
			0,
			D2D1_RENDER_TARGET_USAGE_NONE,
			D2D1_FEATURE_LEVEL_DEFAULT
		);
		HRESULT hr = D2D::g_Direct2dFactory->CreateWicBitmapRenderTarget(dxImage->GetIWICBitmap(), defaultOption, (ID2D1RenderTarget**)&m_render);
		m_render->BeginDraw();
	}


	DXRender::~DXRender() {
		if (m_render) {
			m_render->EndDraw();
		}
		if (m_font) {
			delete m_font;
		}
		SafeRelease(&m_render);
		SafeRelease(&m_brush);
		SafeRelease(&m_pStrokeStyle);
	}
	ID2D1SolidColorBrush* DXRender::GetBrush()
	{
		if (m_brush == NULL) {
			m_render->CreateSolidColorBrush(D2D_COLOR_F{ 0,0,0,1 }, &m_brush);
		}
		return m_brush;
	}
	ID2D1StrokeStyle* DXRender::GetStrokeStyle() {
		return m_pStrokeStyle;
	}
	void DXRender::SetFont(const std::wstring& fontFamily, float fontSize) {
		if (m_font != NULL) {
			if (m_font->GetFontFamily() == fontFamily && (std::fabs(m_font->GetFontSize() - fontSize) < EZUI_FLOAT_EPSILON)) {
				return;
			}
			delete m_font;
		}
		m_font = new Font(fontFamily, fontSize);
	}
	void DXRender::SetFont(const Font& _copy_font) {
		if (m_font != NULL) {
			if (*m_font == _copy_font) {
				return;
			}
			delete m_font;
		}
		m_font = new Font(_copy_font);
	}
	void DXRender::SetColor(const __EzUI__Color& color) {
		if (m_brush == NULL) {
			m_render->CreateSolidColorBrush(__To_D2D_COLOR_F(color), &m_brush);
		}
		else {
			m_brush->SetColor(__To_D2D_COLOR_F(color));
		}
	}
	void DXRender::SetStrokeStyle(StrokeStyle strokeStyle)
	{
		if (m_pStrokeStyle != NULL) {
			SafeRelease(&m_pStrokeStyle);
		}
		if (strokeStyle == StrokeStyle::Dash) {
			// 使用系统默认的虚线样式
			D2D1_DASH_STYLE dashStyle = D2D1_DASH_STYLE_DASH;  // 常规虚线样式
			// 创建虚线样式
			D2D::g_Direct2dFactory->CreateStrokeStyle(
				D2D1::StrokeStyleProperties(
					D2D1_CAP_STYLE_FLAT,                // 线帽样式
					D2D1_CAP_STYLE_FLAT,                // 结束线帽样式
					D2D1_CAP_STYLE_ROUND,               // 虚线部分的线帽样式
					D2D1_LINE_JOIN_ROUND,               // 线段连接样式
					10.0f,                              // 斜接限制
					dashStyle,                          // 设置虚线样式为常规虚线
					0.0f                                 // 自定义虚线的间隔（不需要）
				),
				NULL, 0, &m_pStrokeStyle);
		}
	}
	void DXRender::DrawTextLayout(const TextLayout& textLayout, const PointF& startLacation) {
		m_render->DrawTextLayout(D2D1_POINT_2F{ startLacation.X ,startLacation.Y }, textLayout.Get(), GetBrush());
	}
	void DXRender::DrawString(const std::wstring& text, const  RectF& rect, ezui::TextAlign textAlign) {
		TextLayout textLayout(text, *m_font, { rect.Width, rect.Height }, textAlign);
		this->DrawTextLayout(textLayout, { rect.X,rect.Y });
	}
	void DXRender::DrawLine(const PointF& A, const PointF& B, float width) {
		m_render->DrawLine(D2D1_POINT_2F{ A.X,A.Y }, D2D1_POINT_2F{ B.X,B.Y }, GetBrush(), width, GetStrokeStyle());
	}

	void DXRender::DrawRectangle(const RectF& rect, float _radius, float width)
	{
		if (_radius > 0) {
			float radius = GetMaxRadius(rect.Width, rect.Height, _radius);
			D2D1_ROUNDED_RECT roundRect{ __To_D2D_RectF(rect), radius, radius };
			m_render->DrawRoundedRectangle(roundRect, GetBrush(), width, GetStrokeStyle());
		}
		else {
			m_render->DrawRectangle(__To_D2D_RectF(rect), GetBrush(), width, GetStrokeStyle());
		}
	}


	void DXRender::FillRectangle(const RectF& rect, float _radius) {
		if (_radius > 0) {
			float radius = GetMaxRadius(rect.Width, rect.Height, _radius);
			D2D1_ROUNDED_RECT roundRect{ __To_D2D_RectF(rect), radius, radius };
			m_render->FillRoundedRectangle(roundRect, GetBrush());
		}
		else {
			m_render->FillRectangle(__To_D2D_RectF(rect), GetBrush());
		}
	}

	void DXRender::SetTransform(float offsetX, float offsetY)
	{
		this->m_offset.X = offsetX;
		this->m_offset.Y = offsetY;
		this->SetTransform(this->m_offset.X, this->m_offset.Y, this->m_rotatePoint.X, this->m_rotatePoint.Y, this->m_angle);
	}

	void DXRender::SetTransform(float startX, float startY, float angle) {
		this->m_rotatePoint.X = startX;
		this->m_rotatePoint.Y = startY;
		this->m_angle = angle;
		this->SetTransform(this->m_offset.X, this->m_offset.Y, this->m_rotatePoint.X, this->m_rotatePoint.Y, this->m_angle);
	}

	void DXRender::SetTransform(float offsetX, float offsetY, float startX, float startY, float angle)
	{
		// 创建D2D矩阵转换对象 平移变换
		D2D1::Matrix3x2F transformMatrix = D2D1::Matrix3x2F::Translation(offsetX, offsetY);
		// 判断是否需要进行旋转变换
		if (angle != 0)
		{
			// 旋转变换
			transformMatrix = transformMatrix * D2D1::Matrix3x2F::Rotation(angle, D2D1_POINT_2F{ startX, startY });
		}
		// 将转换矩阵应用于绘制对象
		m_render->SetTransform(transformMatrix);
	}

	void DXRender::DrawBezier(const PointF& startPoint, const Bezier& points, float width) {
		ID2D1GeometrySink* pSink = NULL;
		ID2D1PathGeometry* pathGeometry = NULL;
		D2D::g_Direct2dFactory->CreatePathGeometry(&pathGeometry);
		pathGeometry->Open(&pSink);
		pSink->BeginFigure(__To_D2D_PointF(startPoint), D2D1_FIGURE_BEGIN_FILLED);
		D2D1_BEZIER_SEGMENT bzr{ __To_D2D_PointF(points.point1) ,__To_D2D_PointF(points.point2) ,__To_D2D_PointF(points.point3) };
		pSink->AddBezier(bzr);
		pSink->EndFigure(D2D1_FIGURE_END_OPEN);
		pSink->Close();
		m_render->DrawGeometry(pathGeometry, GetBrush(), width, GetStrokeStyle());
		SafeRelease(&pathGeometry);
		SafeRelease(&pSink);
	}
	void DXRender::DrawBezier(const PointF& startPoint, std::list<Bezier>& beziers, float width)
	{
		ID2D1GeometrySink* pSink = NULL;
		ID2D1PathGeometry* pathGeometry = NULL;
		D2D::g_Direct2dFactory->CreatePathGeometry(&pathGeometry);
		pathGeometry->Open(&pSink);
		pSink->BeginFigure(__To_D2D_PointF(startPoint), D2D1_FIGURE_BEGIN_FILLED);
		for (auto& it : beziers) {
			D2D1_BEZIER_SEGMENT bzr{ __To_D2D_PointF(it.point1) ,__To_D2D_PointF(it.point2) ,__To_D2D_PointF(it.point3) };
			pSink->AddBezier(bzr);
		}
		pSink->EndFigure(D2D1_FIGURE_END_OPEN);
		pSink->Close();
		m_render->DrawGeometry(pathGeometry, GetBrush(), width, GetStrokeStyle());
		SafeRelease(&pathGeometry);
		SafeRelease(&pSink);
	}

	void DXRender::PushLayer(const Geometry& dxGeometry) {
		ID2D1Layer* layer = NULL;
		m_render->CreateLayer(&layer);
		m_render->PushLayer(D2D1::LayerParameters(D2D1::InfiniteRect(), dxGeometry.Get()), layer);//放入layer
		SafeRelease(&layer);
	}
	void DXRender::PopLayer() {
		m_render->PopLayer();
	}
	void DXRender::PushAxisAlignedClip(const RectF& rectBounds) {
		m_render->PushAxisAlignedClip(__To_D2D_RectF(rectBounds), D2D1_ANTIALIAS_MODE::D2D1_ANTIALIAS_MODE_PER_PRIMITIVE);
	}
	void DXRender::PopAxisAlignedClip() {
		m_render->PopAxisAlignedClip();
	}

	void DXRender::DrawImage(DXImage* image, const  RectF& tagRect, float opacity) {
		_NOREND_IMAGE_
			if (image->Visible == false) return;
		//解码
		image->DecodeOfRender(m_render);
		ID2D1Bitmap* bitmap = image->Get();
		if (!bitmap) {
			//解码失败
			return;
		}
		ImageSizeMode imageSizeMode = image->SizeMode;
		const Rect& sourceRect = image->Clip;
		//计算坐标
		RectF rect(tagRect.X, tagRect.Y, tagRect.Width, tagRect.Height);
		//转换坐标,缩放
		Size imgSize(image->Width(), image->Height());
		if (!sourceRect.IsEmptyArea()) {
			imgSize.Width = sourceRect.Width;
			imgSize.Height = sourceRect.Height;
		}

		//加上在Owner区域的偏移
		rect.X += image->DrawPosition.X;
		rect.Y += image->DrawPosition.Y;

		RectF realRendRect;//最终渲染的矩形位置
		if (!image->DrawSize.Empty()) {
			//限制在Owner中的绘制区域
			realRendRect = RectF(rect.X, rect.Y, image->DrawSize.Width, image->DrawSize.Height);
		}
		else {
			//不限制绘制区域 根据imageSizeMode属性进行坐标转换
			realRendRect = RectF::Transformation(imageSizeMode, rect, SizeF(imgSize.Width, imgSize.Height));
		}
		//开始绘制
		D2D_RECT_F drawRectF = __To_D2D_RectF(realRendRect);
		if (!sourceRect.IsEmptyArea()) {
			//裁剪图片部分内容进行绘制
			D2D_RECT_F imageClipRectF = __To_D2D_RectF(sourceRect);
			m_render->DrawBitmap(bitmap, drawRectF, opacity, D2D1_BITMAP_INTERPOLATION_MODE_LINEAR, imageClipRectF);
		}
		else {
			//不裁剪图片的方式进行绘制
			m_render->DrawBitmap(bitmap, drawRectF, opacity);
		}
	}
	void DXRender::DrawEllipse(const RectF& rectF, float strokeWidth)
	{
		PieGeometry pie(rectF, 0, 360);
		DrawGeometry(pie.Get(), strokeWidth);
	}
	void DXRender::FillEllipse(const RectF& rectF)
	{
		PieGeometry pie(rectF, 0, 360);
		FillGeometry(pie.Get());
	}

	void DXRender::DrawPie(const RectF& rectF, float startAngle, float endAngle, float strokeWidth)
	{
		PieGeometry pie(rectF, startAngle, endAngle);
		DrawGeometry(pie.Get(), strokeWidth);
	}
	void DXRender::FillPie(const RectF& rectF, float startAngle, float endAngle)
	{
		PieGeometry pie(rectF, startAngle, endAngle);
		FillGeometry(pie.Get());
	}
	void DXRender::DrawPoint(const PointF& pt) {
		D2D1_ELLIPSE ellipse = D2D1::Ellipse(__To_D2D_PointF(pt), 0.5, 0.5);
		m_render->FillEllipse(ellipse, GetBrush());
	}
	void DXRender::DrawArc(const RectF& rect, float startAngle, float sweepAngle, float width) {
	}
	void DXRender::DrawArc(const PointF& point1, const PointF& point2, const PointF& point3, float width)
	{
	}
	void DXRender::DrawGeometry(ID2D1Geometry* geometry, float width)
	{
		m_render->DrawGeometry(geometry, GetBrush(), width, this->GetStrokeStyle());
	}
	void DXRender::FillGeometry(ID2D1Geometry* geometry)
	{
		m_render->FillGeometry(geometry, GetBrush());
	}
	void DXRender::DrawGeometry(Geometry* path, float width)
	{
		DrawGeometry(path->Get(), width);
	}
	void DXRender::FillGeometry(Geometry* path)
	{
		FillGeometry(path->Get());
	}
	void DXRender::Flush()
	{
		m_render->Flush();
	}
	ID2D1DCRenderTarget* DXRender::Get() {
		return m_render;
	}
};

#endif