no message

cocos/platform/win32/modules/Accelerometer.cpp

@@ -0,0 +1,39 @@
+/****************************************************************************
+ Copyright (c) 2017-2023 Xiamen Yaji Software Co., Ltd.
+
+ http://www.cocos.com
+
+ 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 "platform/win32/modules/Accelerometer.h"
+
+namespace cc {
+void Accelerometer::setAccelerometerEnabled(bool isEnabled) {
+}
+
+void Accelerometer::setAccelerometerInterval(float interval) {
+}
+
+const Accelerometer::MotionValue &Accelerometer::getDeviceMotionValue() {
+    static MotionValue motionValue;
+    return motionValue;
+}
+
+} // namespace cc

cocos/platform/win32/modules/Accelerometer.h

@@ -0,0 +1,49 @@
+/****************************************************************************
+ Copyright (c) 2017-2023 Xiamen Yaji Software Co., Ltd.
+
+ http://www.cocos.com
+
+ 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.
+****************************************************************************/
+
+#pragma once
+
+#include "platform/interfaces/modules/IAccelerometer.h"
+
+namespace cc {
+
+class CC_DLL Accelerometer : public IAccelerometer {
+public:
+    /**
+     * To enable or disable accelerometer.
+     */
+    void setAccelerometerEnabled(bool isEnabled) override;
+
+    /**
+     *  Sets the interval of accelerometer.
+     */
+    void setAccelerometerInterval(float interval) override;
+
+    /**
+     *  Gets the motion value of current device.
+     */
+    const MotionValue &getDeviceMotionValue() override;
+};
+
+} // namespace cc

cocos/platform/win32/modules/Battery.cpp

@@ -0,0 +1,33 @@
+/****************************************************************************
+ Copyright (c) 2017-2023 Xiamen Yaji Software Co., Ltd.
+
+ http://www.cocos.com
+
+ 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 "platform/win32/modules/Battery.h"
+
+namespace cc {
+
+float Battery::getBatteryLevel() const {
+    return 1.0F;
+}
+
+} // namespace cc

cocos/platform/win32/modules/Battery.h

@@ -0,0 +1,36 @@
+/****************************************************************************
+ Copyright (c) 2017-2023 Xiamen Yaji Software Co., Ltd.
+
+ http://www.cocos.com
+
+ 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.
+****************************************************************************/
+
+#pragma once
+
+#include "platform/interfaces/modules/IBattery.h"
+
+namespace cc {
+
+class CC_DLL Battery : public IBattery {
+public:
+    float getBatteryLevel() const override;
+};
+
+} // namespace cc

cocos/platform/win32/modules/CanvasRenderingContext2DDelegate.cpp

@@ -0,0 +1,508 @@
+/****************************************************************************
+ Copyright (c) 2018-2023 Xiamen Yaji Software Co., Ltd.
+
+ http://www.cocos.com
+
+ 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 "platform/win32/modules/CanvasRenderingContext2DDelegate.h"
+#include "base/memory/Memory.h"
+
+namespace {
+void fillRectWithColor(uint8_t *buf, uint32_t totalWidth, uint32_t totalHeight, uint32_t x, uint32_t y, uint32_t width, uint32_t height, uint8_t r, uint8_t g, uint8_t b, uint8_t a) {
+    CC_ASSERT(x + width <= totalWidth);
+    CC_ASSERT(y + height <= totalHeight);
+
+    uint32_t y0 = y;
+    uint32_t y1 = y + height;
+    uint8_t *p;
+    for (uint32_t offsetY = y0; offsetY < y1; ++offsetY) {
+        for (uint32_t offsetX = x; offsetX < (x + width); ++offsetX) {
+            p = buf + (totalWidth * offsetY + offsetX) * 4;
+            *p++ = r;
+            *p++ = g;
+            *p++ = b;
+            *p++ = a;
+        }
+    }
+}
+} // namespace
+
+namespace cc {
+CanvasRenderingContext2DDelegate::CanvasRenderingContext2DDelegate() {
+    HDC hdc = GetDC(_wnd);
+    _DC = CreateCompatibleDC(hdc);
+    ReleaseDC(_wnd, hdc);
+}
+
+CanvasRenderingContext2DDelegate::~CanvasRenderingContext2DDelegate() {
+    deleteBitmap();
+    removeCustomFont();
+    if (_DC)
+        DeleteDC(_DC);
+}
+
+void CanvasRenderingContext2DDelegate::recreateBuffer(float w, float h) {
+    _bufferWidth = w;
+    _bufferHeight = h;
+    if (_bufferWidth < 1.0F || _bufferHeight < 1.0F) {
+        deleteBitmap();
+        return;
+    }
+
+    auto textureSize = static_cast<int>(_bufferWidth * _bufferHeight * 4);
+    auto *data = static_cast<uint8_t *>(malloc(sizeof(uint8_t) * textureSize));
+    memset(data, 0x00, textureSize);
+    _imageData.fastSet(data, textureSize);
+
+    prepareBitmap(static_cast<int>(_bufferWidth), static_cast<int>(_bufferHeight));
+}
+
+void CanvasRenderingContext2DDelegate::beginPath() {
+    // called: set_lineWidth() -> beginPath() -> moveTo() -> lineTo() -> stroke(), when draw line
+    _hpen = CreatePen(PS_SOLID, static_cast<int>(_lineWidth), RGB(255, 255, 255));
+    // the return value of SelectObject is a handle to the object being replaced, so we should delete them to avoid memory leak
+    HGDIOBJ hOldPen = SelectObject(_DC, _hpen);
+    HGDIOBJ hOldBmp = SelectObject(_DC, _bmp);
+    DeleteObject(hOldPen);
+    DeleteObject(hOldBmp);
+
+    SetBkMode(_DC, TRANSPARENT);
+}
+
+void CanvasRenderingContext2DDelegate::closePath() {
+}
+
+void CanvasRenderingContext2DDelegate::moveTo(float x, float y) {
+    MoveToEx(_DC, static_cast<int>(x), static_cast<int>(-(y - _bufferHeight - _fontSize)), nullptr);
+}
+
+void CanvasRenderingContext2DDelegate::lineTo(float x, float y) {
+    LineTo(_DC, static_cast<int>(x), static_cast<int>(-(y - _bufferHeight - _fontSize)));
+}
+
+void CanvasRenderingContext2DDelegate::stroke() {
+    DeleteObject(_hpen);
+    if (_bufferWidth < 1.0F || _bufferHeight < 1.0F) {
+        return;
+    }
+
+    fillTextureData();
+}
+
+void CanvasRenderingContext2DDelegate::saveContext() {
+    _savedDC = SaveDC(_DC);
+}
+
+void CanvasRenderingContext2DDelegate::restoreContext() {
+    BOOL ret = RestoreDC(_DC, _savedDC);
+    if (0 == ret) {
+        SE_LOGD("CanvasRenderingContext2DImpl restore context failed.\n");
+    }
+}
+
+void CanvasRenderingContext2DDelegate::clearRect(float /*x*/, float /*y*/, float w, float h) {
+    if (_bufferWidth < 1.0F || _bufferHeight < 1.0F) {
+        return;
+    }
+
+    if (_imageData.isNull()) {
+        return;
+    }
+
+    recreateBuffer(w, h);
+}
+
+void CanvasRenderingContext2DDelegate::fillRect(float x, float y, float w, float h) {
+    if (_bufferWidth < 1.0F || _bufferHeight < 1.0F) {
+        return;
+    }
+
+    //not filled all Bits in buffer? the buffer length is _bufferWidth * _bufferHeight * 4, but it filled _bufferWidth * _bufferHeight * 3?
+    uint8_t *buffer = _imageData.getBytes();
+    if (buffer) {
+        uint8_t r = static_cast<uint8_t>(_fillStyle[0] * 255.0f);
+        uint8_t g = static_cast<uint8_t>(_fillStyle[1] * 255.0f);
+        uint8_t b = static_cast<uint8_t>(_fillStyle[2] * 255.0f);
+        uint8_t a = static_cast<uint8_t>(_fillStyle[3] * 255.0f);
+        fillRectWithColor(buffer,
+                          static_cast<uint32_t>(_bufferWidth),
+                          static_cast<uint32_t>(_bufferHeight),
+                          static_cast<uint32_t>(x),
+                          static_cast<uint32_t>(y),
+                          static_cast<uint32_t>(w),
+                          static_cast<uint32_t>(h), r, g, b, a);
+    }
+}
+
+void CanvasRenderingContext2DDelegate::fillText(const ccstd::string &text, float x, float y, float /*maxWidth*/) {
+    if (text.empty() || _bufferWidth < 1.0F || _bufferHeight < 1.0F) {
+        return;
+    }
+
+    SIZE textSize = {0, 0};
+    Point offsetPoint = convertDrawPoint(Point{x, y}, text);
+
+    drawText(text, (int)offsetPoint[0], (int)offsetPoint[1]);
+    fillTextureData();
+}
+
+void CanvasRenderingContext2DDelegate::strokeText(const ccstd::string &text, float /*x*/, float /*y*/, float /*maxWidth*/) const {
+    if (text.empty() || _bufferWidth < 1.0F || _bufferHeight < 1.0F) {
+        return;
+    }
+}
+
+CanvasRenderingContext2DDelegate::Size CanvasRenderingContext2DDelegate::measureText(const ccstd::string &text) {
+    if (text.empty())
+        return ccstd::array<float, 2>{0.0f, 0.0f};
+
+    int bufferLen = 0;
+    wchar_t *pwszBuffer = CanvasRenderingContext2DDelegate::utf8ToUtf16(text, &bufferLen);
+    Size size = sizeWithText(pwszBuffer, bufferLen);
+    //SE_LOGD("CanvasRenderingContext2DImpl::measureText: %s, %d, %d\n", text.c_str(), size.cx, size.cy);
+    CC_SAFE_DELETE_ARRAY(pwszBuffer);
+    return size;
+}
+
+void CanvasRenderingContext2DDelegate::updateFont(const ccstd::string &fontName,
+                                                  float fontSize,
+                                                  bool bold,
+                                                  bool italic,
+                                                  bool /* oblique */,
+                                                  bool /* smallCaps */) {
+    do {
+        _fontName = fontName;
+        _fontSize = static_cast<int>(fontSize);
+        ccstd::string fontPath;
+        LOGFONTA tFont = {0};
+        if (!_fontName.empty()) {
+            // firstly, try to create font from ttf file
+            const auto &fontInfoMap = getFontFamilyNameMap();
+            auto iter = fontInfoMap.find(_fontName);
+            if (iter != fontInfoMap.end()) {
+                fontPath = iter->second;
+                ccstd::string tmpFontPath = fontPath;
+                size_t nFindPos = tmpFontPath.rfind("/");
+                tmpFontPath = &tmpFontPath[nFindPos + 1];
+                nFindPos = tmpFontPath.rfind(".");
+                // IDEA: draw ttf failed if font file name not equal font face name
+                // for example: "DejaVuSansMono-Oblique" not equal "DejaVu Sans Mono"  when using DejaVuSansMono-Oblique.ttf
+                _fontName = tmpFontPath.substr(0, nFindPos);
+            } else {
+                auto nFindPos = fontName.rfind("/");
+                if (nFindPos != fontName.npos) {
+                    if (fontName.length() == nFindPos + 1) {
+                        _fontName = "";
+                    } else {
+                        _fontName = &_fontName[nFindPos + 1];
+                    }
+                }
+            }
+            tFont.lfCharSet = DEFAULT_CHARSET;
+            strcpy_s(tFont.lfFaceName, LF_FACESIZE, _fontName.c_str());
+        }
+
+        if (_fontSize) {
+            tFont.lfHeight = -_fontSize;
+        }
+
+        if (bold) {
+            tFont.lfWeight = FW_BOLD;
+        } else {
+            tFont.lfWeight = FW_NORMAL;
+        }
+
+        tFont.lfItalic = italic;
+
+        // disable Cleartype
+        tFont.lfQuality = ANTIALIASED_QUALITY;
+
+        // delete old font
+        removeCustomFont();
+
+        if (!fontPath.empty()) {
+            _curFontPath = fontPath;
+            wchar_t *pwszBuffer = utf8ToUtf16(_curFontPath);
+            if (pwszBuffer) {
+                if (AddFontResource(pwszBuffer)) {
+                    SendMessage(_wnd, WM_FONTCHANGE, 0, 0);
+                }
+                delete[] pwszBuffer;
+                pwszBuffer = nullptr;
+            }
+        }
+
+        // create new font
+        _font = CreateFontIndirectA(&tFont);
+        if (!_font) {
+            // create failed, use default font
+            SE_LOGE("Failed to create custom font(font name: %s, font size: %f), use default font.\n",
+                    _fontName.c_str(), fontSize);
+        } else {
+            SelectObject(_DC, _font);
+            SendMessage(_wnd, WM_FONTCHANGE, 0, 0);
+        }
+    } while (false);
+}
+
+void CanvasRenderingContext2DDelegate::setTextAlign(TextAlign align) {
+    _textAlign = align;
+}
+
+void CanvasRenderingContext2DDelegate::setTextBaseline(TextBaseline baseline) {
+    _textBaseLine = baseline;
+}
+
+void CanvasRenderingContext2DDelegate::setFillStyle(uint8_t r, uint8_t g, uint8_t b, uint8_t a) {
+    _fillStyle = {r / 255.0F, g / 255.0F, b / 255.0F, a / 255.0F};
+}
+
+void CanvasRenderingContext2DDelegate::setStrokeStyle(uint8_t r, uint8_t g, uint8_t b, uint8_t a) {
+    _strokeStyle = {r / 255.0F, g / 255.0F, b / 255.0F, a / 255.0F};
+}
+
+void CanvasRenderingContext2DDelegate::setLineWidth(float lineWidth) {
+    _lineWidth = lineWidth;
+}
+
+const cc::Data &CanvasRenderingContext2DDelegate::getDataRef() const {
+    return _imageData;
+}
+
+// change utf-8 string to utf-16, pRetLen is the string length after changing
+wchar_t *CanvasRenderingContext2DDelegate::utf8ToUtf16(const ccstd::string &str, int *pRetLen /* = nullptr*/) {
+    wchar_t *pwszBuffer = nullptr;
+    do {
+        if (str.empty()) {
+            break;
+        }
+        int nLen = static_cast<int>(str.size());
+        int nBufLen = nLen + 1;
+        pwszBuffer = ccnew wchar_t[nBufLen];
+        CC_BREAK_IF(!pwszBuffer);
+        memset(pwszBuffer, 0, sizeof(wchar_t) * nBufLen);
+        // str.size() not equal actuallyLen for Chinese char
+        int actuallyLen = MultiByteToWideChar(CP_UTF8, 0, str.c_str(), nLen, pwszBuffer, nBufLen);
+        // SE_LOGE("_utf8ToUtf16, str:%s, strLen:%d, retLen:%d\n", str.c_str(), str.size(), actuallyLen);
+        if (pRetLen != nullptr) {
+            *pRetLen = actuallyLen;
+        }
+    } while (false);
+    return pwszBuffer;
+}
+
+void CanvasRenderingContext2DDelegate::removeCustomFont() {
+    HFONT hDefFont = (HFONT)GetStockObject(DEFAULT_GUI_FONT);
+    if (hDefFont != _font) {
+        DeleteObject(SelectObject(_DC, hDefFont));
+    }
+    // release temp font resource
+    if (!_curFontPath.empty()) {
+        wchar_t *pwszBuffer = utf8ToUtf16(_curFontPath);
+        if (pwszBuffer) {
+            RemoveFontResource(pwszBuffer);
+            SendMessage(_wnd, WM_FONTCHANGE, 0, 0);
+            delete[] pwszBuffer;
+            pwszBuffer = nullptr;
+        }
+        _curFontPath.clear();
+    }
+}
+
+// x, y offset value
+int CanvasRenderingContext2DDelegate::drawText(const ccstd::string &text, int x, int y) {
+    int nRet = 0;
+    wchar_t *pwszBuffer = nullptr;
+    do {
+        CC_BREAK_IF(text.empty());
+
+        DWORD dwFmt = DT_SINGLELINE | DT_NOPREFIX;
+
+        int bufferLen = 0;
+        pwszBuffer = utf8ToUtf16(text, &bufferLen);
+
+        Size newSize = sizeWithText(pwszBuffer, bufferLen);
+
+        _textSize = newSize;
+
+        RECT rcText = {0};
+
+        rcText.right = static_cast<int>(newSize[0]);
+        rcText.bottom = static_cast<int>(newSize[1]);
+
+        LONG offsetX = x;
+        LONG offsetY = y;
+        if (offsetX || offsetY) {
+            OffsetRect(&rcText, offsetX, offsetY);
+        }
+
+        // SE_LOGE("_drawText text,%s size: (%d, %d) offset after convert: (%d, %d) \n", text.c_str(), newSize.cx, newSize.cy, offsetX, offsetY);
+
+        SetBkMode(_DC, TRANSPARENT);
+        SetTextColor(_DC, RGB(255, 255, 255)); // white color
+
+        // draw text
+        nRet = DrawTextW(_DC, pwszBuffer, bufferLen, &rcText, dwFmt);
+    } while (false);
+    CC_SAFE_DELETE_ARRAY(pwszBuffer);
+
+    return nRet;
+}
+
+CanvasRenderingContext2DDelegate::Size CanvasRenderingContext2DDelegate::sizeWithText(const wchar_t *pszText, int nLen) {
+    Size tRet{0, 0};
+    do {
+        CC_BREAK_IF(!pszText || nLen <= 0);
+
+        RECT rc = {0, 0, 0, 0};
+        DWORD dwCalcFmt = DT_CALCRECT | DT_NOPREFIX;
+
+        // measure text size
+        DrawTextW(_DC, pszText, nLen, &rc, dwCalcFmt);
+
+        tRet[0] = static_cast<float>(rc.right);
+        tRet[1] = static_cast<float>(rc.bottom);
+    } while (false);
+
+    return tRet;
+}
+
+void CanvasRenderingContext2DDelegate::prepareBitmap(int nWidth, int nHeight) {
+    // release bitmap
+    deleteBitmap();
+
+    if (nWidth > 0 && nHeight > 0) {
+        _bmp = CreateBitmap(nWidth, nHeight, 1, 32, nullptr);
+        SelectObject(_DC, _bmp);
+    }
+}
+
+void CanvasRenderingContext2DDelegate::deleteBitmap() {
+    if (_bmp) {
+        DeleteObject(_bmp);
+        _bmp = nullptr;
+    }
+}
+
+void CanvasRenderingContext2DDelegate::fillTextureData() {
+    do {
+        auto dataLen = static_cast<int>(_bufferWidth * _bufferHeight * 4);
+        auto *dataBuf = static_cast<unsigned char *>(malloc(sizeof(unsigned char) * dataLen));
+        CC_BREAK_IF(!dataBuf);
+        unsigned char *imageBuf = _imageData.getBytes();
+        CC_BREAK_IF(!imageBuf);
+
+        struct
+        {
+            BITMAPINFOHEADER bmiHeader;
+            int mask[4];
+        } bi = {0};
+        bi.bmiHeader.biSize = sizeof(bi.bmiHeader);
+        CC_BREAK_IF(!GetDIBits(_DC, _bmp, 0, 0,
+                               nullptr, (LPBITMAPINFO)&bi, DIB_RGB_COLORS));
+
+        // copy pixel data
+        bi.bmiHeader.biHeight = (bi.bmiHeader.biHeight > 0) ? -bi.bmiHeader.biHeight : bi.bmiHeader.biHeight;
+        GetDIBits(_DC, _bmp, 0, static_cast<UINT>(_bufferHeight), dataBuf,
+                  (LPBITMAPINFO)&bi, DIB_RGB_COLORS);
+
+        uint8_t r = static_cast<uint8_t>(round(_fillStyle[0] * 255));
+        uint8_t g = static_cast<uint8_t>(round(_fillStyle[1] * 255));
+        uint8_t b = static_cast<uint8_t>(round(_fillStyle[2] * 255));
+        COLORREF textColor = (b << 16 | g << 8 | r) & 0x00ffffff;
+        COLORREF *pPixel = nullptr;
+        COLORREF *pImage = nullptr;
+        int bufferHeight = static_cast<int>(_bufferHeight);
+        int bufferWidth = static_cast<int>(_bufferWidth);
+        for (int y = 0; y < bufferHeight; ++y) {
+            pPixel = (COLORREF *)dataBuf + y * bufferWidth;
+            pImage = (COLORREF *)imageBuf + y * bufferWidth;
+            for (int x = 0; x < bufferWidth; ++x) {
+                COLORREF &clr = *pPixel;
+                COLORREF &val = *pImage;
+                // Because text is drawn in white color, and background color is black,
+                // so the red value is equal to alpha value. And we should keep this value
+                // as it includes anti-atlas information.
+                uint8_t alpha = GetRValue(clr);
+                if (alpha > 0) {
+                    val = (alpha << 24) | textColor;
+                }
+                ++pPixel;
+                ++pImage;
+            }
+        }
+        free(dataBuf);
+    } while (false);
+}
+
+ccstd::array<float, 2> CanvasRenderingContext2DDelegate::convertDrawPoint(Point point, const ccstd::string &text) {
+    Size textSize = measureText(text);
+    if (_textAlign == TextAlign::CENTER) {
+        point[0] -= textSize[0] / 2.0f;
+    } else if (_textAlign == TextAlign::RIGHT) {
+        point[0] -= textSize[0];
+    }
+
+    if (_textBaseLine == TextBaseline::TOP) {
+        // DrawText default
+        GetTextMetrics(_DC, &_tm);
+        point[1] += -_tm.tmInternalLeading;
+    } else if (_textBaseLine == TextBaseline::MIDDLE) {
+        point[1] += -textSize[1] / 2.0f;
+    } else if (_textBaseLine == TextBaseline::BOTTOM) {
+        point[1] += -textSize[1];
+    } else if (_textBaseLine == TextBaseline::ALPHABETIC) {
+        GetTextMetrics(_DC, &_tm);
+        point[1] -= _tm.tmAscent;
+    }
+
+    return point;
+}
+
+void CanvasRenderingContext2DDelegate::fill() {
+}
+
+void CanvasRenderingContext2DDelegate::setLineCap(const ccstd::string & /* lineCap */) {
+}
+
+void CanvasRenderingContext2DDelegate::setLineJoin(const ccstd::string & /* lineCap */) {
+}
+
+void CanvasRenderingContext2DDelegate::fillImageData(const Data & /* imageData */,
+                                                     float /* imageWidth */,
+                                                     float /* imageHeight */,
+                                                     float /* offsetX */,
+                                                     float /* offsetY */) {
+}
+
+void CanvasRenderingContext2DDelegate::strokeText(const ccstd::string & /* text */,
+                                                  float /* x */,
+                                                  float /* y */,
+                                                  float /* maxWidth */) {
+}
+
+void CanvasRenderingContext2DDelegate::rect(float /* x */,
+                                            float /* y */,
+                                            float /* w */,
+                                            float /* h */) {
+}
+
+} // namespace cc

cocos/platform/win32/modules/CanvasRenderingContext2DDelegate.h

@@ -0,0 +1,121 @@
+/****************************************************************************
+ Copyright (c) 2018-2023 Xiamen Yaji Software Co., Ltd.
+
+ http://www.cocos.com
+
+ 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.
+****************************************************************************/
+
+#pragma once
+
+#include "platform/interfaces/modules/canvas/ICanvasRenderingContext2D.h"
+
+#include <Windows.h>
+#include <cstdint>
+#include <regex>
+#include "base/csscolorparser.h"
+#include "base/std/container/array.h"
+#include "cocos/bindings/jswrapper/SeApi.h"
+#include "cocos/bindings/manual/jsb_platform.h"
+#include "math/Math.h"
+#include "platform/FileUtils.h"
+
+namespace cc {
+
+class CC_DLL CanvasRenderingContext2DDelegate : public ICanvasRenderingContext2D::Delegate {
+public:
+    using Point = ccstd::array<float, 2>;
+    using Vec2 = ccstd::array<float, 2>;
+    using Size = ccstd::array<float, 2>;
+    using Color4F = ccstd::array<float, 4>;
+    using TextAlign = ICanvasRenderingContext2D::TextAlign;
+    using TextBaseline = ICanvasRenderingContext2D::TextBaseline;
+    CanvasRenderingContext2DDelegate();
+    ~CanvasRenderingContext2DDelegate() override;
+
+    void recreateBuffer(float w, float h) override;
+    void beginPath() override;
+    void closePath() override;
+    void moveTo(float x, float y) override;
+    void lineTo(float x, float y) override;
+    void stroke() override;
+    void saveContext() override;
+    void restoreContext() override;
+    void clearRect(float /*x*/, float /*y*/, float w, float h) override;
+    void fillRect(float x, float y, float w, float h) override;
+    void fillText(const ccstd::string &text, float x, float y, float /*maxWidth*/) override;
+    void strokeText(const ccstd::string &text, float /*x*/, float /*y*/, float /*maxWidth*/) const;
+    Size measureText(const ccstd::string &text) override;
+    void updateFont(const ccstd::string &fontName, float fontSize, bool bold, bool italic, bool oblique, bool smallCaps) override;
+    void setTextAlign(TextAlign align) override;
+    void setTextBaseline(TextBaseline baseline) override;
+    void setFillStyle(uint8_t r, uint8_t g, uint8_t b, uint8_t a) override;
+    void setStrokeStyle(uint8_t r, uint8_t g, uint8_t b, uint8_t a) override;
+    void setLineWidth(float lineWidth) override;
+    const cc::Data &getDataRef() const override;
+    void fill() override;
+    void setLineCap(const ccstd::string &lineCap) override;
+    void setLineJoin(const ccstd::string &lineCap) override;
+    void fillImageData(const Data &imageData, float imageWidth, float imageHeight, float offsetX, float offsetY) override;
+    void strokeText(const ccstd::string &text, float /*x*/, float /*y*/, float /*maxWidth*/) override;
+    void rect(float x, float y, float w, float h) override;
+    void updateData() override {}
+    void setShadowBlur(float blur) override {}
+    void setShadowColor(uint8_t r, uint8_t g, uint8_t b, uint8_t a) override {}
+    void setShadowOffsetX(float offsetX) override {}
+    void setShadowOffsetY(float offsetY) override {}
+
+private:
+    static wchar_t *utf8ToUtf16(const ccstd::string &str, int *pRetLen = nullptr);
+    void removeCustomFont();
+    int drawText(const ccstd::string &text, int x, int y);
+    Size sizeWithText(const wchar_t *pszText, int nLen);
+    void prepareBitmap(int nWidth, int nHeight);
+    void deleteBitmap();
+    void fillTextureData();
+    ccstd::array<float, 2> convertDrawPoint(Point point, const ccstd::string &text);
+
+public:
+    HDC _DC{nullptr};
+    HBITMAP _bmp{nullptr};
+
+private:
+    cc::Data _imageData;
+    HFONT _font{static_cast<HFONT>(GetStockObject(DEFAULT_GUI_FONT))};
+    HWND _wnd{nullptr};
+    HPEN _hpen;
+    PAINTSTRUCT _paintStruct;
+    ccstd::string _curFontPath;
+    int _savedDC{0};
+    float _lineWidth{0.0F};
+    float _bufferWidth{0.0F};
+    float _bufferHeight{0.0F};
+
+    ccstd::string _fontName;
+    int _fontSize{0};
+    Size _textSize;
+    TextAlign _textAlign{TextAlign::CENTER};
+    TextBaseline _textBaseLine{TextBaseline::TOP};
+    Color4F _fillStyle;
+    Color4F _strokeStyle;
+
+    TEXTMETRIC _tm;
+};
+
+} // namespace cc

cocos/platform/win32/modules/Network.cpp

@@ -0,0 +1,33 @@
+/****************************************************************************
+ Copyright (c) 2017-2023 Xiamen Yaji Software Co., Ltd.
+
+ http://www.cocos.com
+
+ 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 "platform/win32/modules/Network.h"
+
+namespace cc {
+
+INetwork::NetworkType Network::getNetworkType() const {
+    return INetwork::NetworkType::LAN;
+}
+
+} // namespace cc

cocos/platform/win32/modules/Network.h

@@ -0,0 +1,36 @@
+/****************************************************************************
+ Copyright (c) 2017-2023 Xiamen Yaji Software Co., Ltd.
+
+ http://www.cocos.com
+
+ 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.
+****************************************************************************/
+
+#pragma once
+
+#include "platform/interfaces/modules/INetwork.h"
+
+namespace cc {
+
+class CC_DLL Network : public INetwork {
+public:
+    NetworkType getNetworkType() const override;
+};
+
+} // namespace cc

cocos/platform/win32/modules/Screen.cpp

@@ -0,0 +1,76 @@
+/****************************************************************************
+ Copyright (c) 2021-2023 Xiamen Yaji Software Co., Ltd.
+
+ http://www.cocos.com
+
+ 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 "platform/win32/modules/Screen.h"
+#include "base/Macros.h"
+#include "cocos/bindings/jswrapper/SeApi.h"
+
+#include <Windows.h>
+
+namespace cc {
+
+int Screen::getDPI() const {
+    static int dpi = -1;
+    if (dpi == -1) {
+        HDC hScreenDC = GetDC(nullptr);
+        int PixelsX = GetDeviceCaps(hScreenDC, HORZRES);
+        int MMX = GetDeviceCaps(hScreenDC, HORZSIZE);
+        ReleaseDC(nullptr, hScreenDC);
+        dpi = static_cast<int>(254.0f * PixelsX / MMX / 10);
+    }
+    return dpi;
+}
+
+float Screen::getDevicePixelRatio() const {
+    return 1;
+}
+
+void Screen::setKeepScreenOn(bool value) {
+    CC_UNUSED_PARAM(value);
+}
+
+Screen::Orientation Screen::getDeviceOrientation() const {
+    return Orientation::PORTRAIT;
+}
+
+Vec4 Screen::getSafeAreaEdge() const {
+    return cc::Vec4();
+}
+
+bool Screen::isDisplayStats() {
+    se::AutoHandleScope hs;
+    se::Value ret;
+    char commandBuf[100] = "cc.profiler.isShowingStats();";
+    se::ScriptEngine::getInstance()->evalString(commandBuf, 100, &ret);
+    return ret.toBoolean();
+}
+
+void Screen::setDisplayStats(bool isShow) {
+    se::AutoHandleScope hs;
+    char commandBuf[100] = {0};
+    sprintf(commandBuf, isShow ? "cc.profiler.showStats();" : "cc.profiler.hideStats();");
+    se::ScriptEngine::getInstance()->evalString(commandBuf);
+}
+
+} // namespace cc

cocos/platform/win32/modules/Screen.h

@@ -0,0 +1,50 @@
+/****************************************************************************
+ Copyright (c) 2017-2023 Xiamen Yaji Software Co., Ltd.
+
+ http://www.cocos.com
+
+ 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.
+****************************************************************************/
+
+#pragma once
+
+#include "platform/interfaces/modules/IScreen.h"
+
+namespace cc {
+
+class CC_DLL Screen : public IScreen {
+public:
+    int getDPI() const override;
+    float getDevicePixelRatio() const override;
+    void setKeepScreenOn(bool value) override;
+    Orientation getDeviceOrientation() const override;
+    Vec4 getSafeAreaEdge() const override;
+    /**
+     @brief Get current display stats.
+     @return bool, is displaying stats or not.
+     */
+    bool isDisplayStats() override;
+
+    /**
+     @brief set display stats information.
+     */
+    void setDisplayStats(bool isShow) override;
+};
+
+} // namespace cc

cocos/platform/win32/modules/System.cpp

@@ -0,0 +1,155 @@
+/****************************************************************************
+ Copyright (c) 2021-2023 Xiamen Yaji Software Co., Ltd.
+
+ http://www.cocos.com
+
+ 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 "platform/win32/modules/System.h"
+#include <Windows.h>
+#include "SDL2/SDL_clipboard.h"
+#include "base/memory/Memory.h"
+namespace cc {
+using OSType = System::OSType;
+
+OSType System::getOSType() const {
+    return OSType::WINDOWS;
+}
+
+ccstd::string System::getDeviceModel() const {
+    return "Windows";
+}
+
+System::LanguageType System::getCurrentLanguage() const {
+    LanguageType ret = LanguageType::ENGLISH;
+
+    LCID localeID = GetUserDefaultLCID();
+    unsigned short primaryLanguageID = localeID & 0xFF;
+
+    switch (primaryLanguageID) {
+        case LANG_CHINESE:
+            ret = LanguageType::CHINESE;
+            break;
+        case LANG_ENGLISH:
+            ret = LanguageType::ENGLISH;
+            break;
+        case LANG_FRENCH:
+            ret = LanguageType::FRENCH;
+            break;
+        case LANG_ITALIAN:
+            ret = LanguageType::ITALIAN;
+            break;
+        case LANG_GERMAN:
+            ret = LanguageType::GERMAN;
+            break;
+        case LANG_SPANISH:
+            ret = LanguageType::SPANISH;
+            break;
+        case LANG_DUTCH:
+            ret = LanguageType::DUTCH;
+            break;
+        case LANG_RUSSIAN:
+            ret = LanguageType::RUSSIAN;
+            break;
+        case LANG_KOREAN:
+            ret = LanguageType::KOREAN;
+            break;
+        case LANG_JAPANESE:
+            ret = LanguageType::JAPANESE;
+            break;
+        case LANG_HUNGARIAN:
+            ret = LanguageType::HUNGARIAN;
+            break;
+        case LANG_PORTUGUESE:
+            ret = LanguageType::PORTUGUESE;
+            break;
+        case LANG_ARABIC:
+            ret = LanguageType::ARABIC;
+            break;
+        case LANG_NORWEGIAN:
+            ret = LanguageType::NORWEGIAN;
+            break;
+        case LANG_POLISH:
+            ret = LanguageType::POLISH;
+            break;
+        case LANG_TURKISH:
+            ret = LanguageType::TURKISH;
+            break;
+        case LANG_UKRAINIAN:
+            ret = LanguageType::UKRAINIAN;
+            break;
+        case LANG_ROMANIAN:
+            ret = LanguageType::ROMANIAN;
+            break;
+        case LANG_BULGARIAN:
+            ret = LanguageType::BULGARIAN;
+            break;
+        case LANG_HINDI:
+            ret = LanguageType::HINDI;
+            break;
+    }
+
+    return ret;
+}
+
+ccstd::string System::getCurrentLanguageCode() const {
+    LANGID lid = GetUserDefaultUILanguage();
+    const LCID locale_id = MAKELCID(lid, SORT_DEFAULT);
+    int length = GetLocaleInfoA(locale_id, LOCALE_SISO639LANGNAME, nullptr, 0);
+
+    char *tempCode = reinterpret_cast<char *>(CC_MALLOC(length));
+    GetLocaleInfoA(locale_id, LOCALE_SISO639LANGNAME, tempCode, length);
+    ccstd::string code(tempCode);
+    CC_FREE(tempCode);
+
+    return code;
+}
+
+ccstd::string System::getSystemVersion() const {
+    char buff[256] = {0};
+    HMODULE handle = GetModuleHandleW(L"ntdll.dll");
+    if (handle) {
+        typedef NTSTATUS(WINAPI * RtlGetVersionPtr)(PRTL_OSVERSIONINFOW);
+        RtlGetVersionPtr getVersionPtr = (RtlGetVersionPtr)GetProcAddress(handle, "RtlGetVersion");
+        if (getVersionPtr != NULL) {
+            RTL_OSVERSIONINFOW info;
+            if (getVersionPtr(&info) == 0) { /* STATUS_SUCCESS == 0 */
+                snprintf(buff, sizeof(buff), "Windows version %d.%d.%d", info.dwMajorVersion, info.dwMinorVersion, info.dwBuildNumber);
+                return buff;
+            }
+        }
+    }
+    return buff;
+}
+
+bool System::openURL(const ccstd::string &url) {
+    WCHAR *temp = ccnew WCHAR[url.size() + 1];
+    int urlSize = static_cast<int>(url.size() + 1);
+    MultiByteToWideChar(CP_UTF8, 0, url.c_str(), urlSize, temp, urlSize);
+    HINSTANCE r = ShellExecuteW(NULL, L"open", temp, NULL, NULL, SW_SHOWNORMAL);
+    delete[] temp;
+    return (size_t)r > 32;
+}
+
+void System::copyTextToClipboard(const ccstd::string &text) {
+    SDL_SetClipboardText(text.c_str());
+}
+
+} // namespace cc

cocos/platform/win32/modules/System.h

@@ -0,0 +1,65 @@
+/****************************************************************************
+ Copyright (c) 2021-2023 Xiamen Yaji Software Co., Ltd.
+
+ http://www.cocos.com
+
+ 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.
+****************************************************************************/
+
+#pragma once
+
+#include "platform/interfaces/modules/ISystem.h"
+
+namespace cc {
+
+class CC_DLL System : public ISystem {
+public:
+    /**
+     @brief Get target system type.
+     */
+    OSType getOSType() const override;
+    /**
+     @brief Get target device model.
+     */
+    ccstd::string getDeviceModel() const override;
+    /**
+     @brief Get current language config.
+     @return Current language config.
+     */
+    LanguageType getCurrentLanguage() const override;
+    /**
+     @brief Get current language iso 639-1 code.
+     @return Current language iso 639-1 code.
+     */
+    ccstd::string getCurrentLanguageCode() const override;
+    /**
+     @brief Get system version.
+     @return system version.
+     */
+    ccstd::string getSystemVersion() const override;
+    /**
+     @brief Open url in default browser.
+     @param String with url to open.
+     @return True if the resource located by the URL was successfully opened; otherwise false.
+     */
+    bool openURL(const ccstd::string& url) override;
+    void copyTextToClipboard(const std::string& text) override;
+};
+
+} // namespace cc

cocos/platform/win32/modules/SystemWindow.cpp

@@ -0,0 +1,96 @@
+/****************************************************************************
+ Copyright (c) 2021-2023 Xiamen Yaji Software Co., Ltd.
+
+ http://www.cocos.com
+
+ 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 "platform/win32/modules/SystemWindow.h"
+#include <Windows.h>
+#include <functional>
+#include "base/Log.h"
+#include "engine/EngineEvents.h"
+#include "platform/SDLHelper.h"
+#include "platform/win32/WindowsPlatform.h"
+
+namespace cc {
+SystemWindow::SystemWindow(uint32_t windowId, void *externalHandle)
+: _windowId(windowId) {
+    if (externalHandle) {
+        _windowHandle = reinterpret_cast<uintptr_t>(externalHandle);
+    }
+}
+
+SystemWindow::~SystemWindow() {
+    _windowHandle = 0;
+    _windowId = 0;
+}
+
+bool SystemWindow::createWindow(const char *title,
+                                int w, int h, int flags) {
+    _window = SDLHelper::createWindow(title, w, h, flags);
+    if (!_window) {
+        return false;
+    }
+
+    _width = w;
+    _height = h;
+    _windowHandle = SDLHelper::getWindowHandle(_window);
+    return true;
+}
+
+bool SystemWindow::createWindow(const char *title,
+                                int x, int y, int w,
+                                int h, int flags) {
+    _window = SDLHelper::createWindow(title, x, y, w, h, flags);
+    if (!_window) {
+        return false;
+    }
+
+    _width = w;
+    _height = h;
+    _windowHandle = SDLHelper::getWindowHandle(_window);
+
+    return true;
+}
+
+void SystemWindow::closeWindow() {
+    HWND windowHandle = reinterpret_cast<HWND>(getWindowHandle());
+    if (windowHandle != 0) {
+        ::SendMessageA(windowHandle, WM_CLOSE, 0, 0);
+    }
+}
+
+uint32_t SystemWindow::getWindowId() const {
+    return _windowId;
+}
+
+uintptr_t SystemWindow::getWindowHandle() const {
+    return _windowHandle;
+}
+
+void SystemWindow::setCursorEnabled(bool value) {
+    SDLHelper::setCursorEnabled(value);
+}
+
+SystemWindow::Size SystemWindow::getViewSize() const {
+    return Size{static_cast<float>(_width), static_cast<float>(_height)};
+}
+} // namespace cc

cocos/platform/win32/modules/SystemWindow.h

@@ -0,0 +1,73 @@
+/****************************************************************************
+ Copyright (c) 2021-2023 Xiamen Yaji Software Co., Ltd.
+
+ http://www.cocos.com
+
+ 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.
+****************************************************************************/
+
+#pragma once
+
+#include <iostream>
+#include "platform/interfaces/modules/ISystemWindow.h"
+
+struct SDL_Window;
+
+namespace cc {
+class SDLHelper;
+
+class CC_DLL SystemWindow : public ISystemWindow {
+    friend class SystemWindowManager;
+
+public:
+    explicit SystemWindow(uint32_t windowId, void* externalHandle);
+    ~SystemWindow() override;
+
+    bool createWindow(const char* title,
+                      int w, int h, int flags) override;
+    bool createWindow(const char* title,
+                      int x, int y, int w,
+                      int h, int flags) override;
+    void closeWindow() override;
+
+    uint32_t getWindowId() const override;
+    uintptr_t getWindowHandle() const override;
+
+    Size getViewSize() const override;
+    void setViewSize(uint32_t width, uint32_t height) override {
+        _width = width;
+        _height = height;
+    }
+    /*
+     @brief enable/disable(lock) the cursor, default is enabled
+     */
+    void setCursorEnabled(bool value) override;
+
+private:
+    SDL_Window* getSDLWindow() const { return _window; }
+
+    uint32_t _width{0};
+    uint32_t _height{0};
+
+    uint32_t _windowId{0};
+    uintptr_t _windowHandle{0};
+    SDL_Window* _window{nullptr};
+};
+
+} // namespace cc

cocos/platform/win32/modules/SystemWindowManager.cpp

@@ -0,0 +1,88 @@
+/****************************************************************************
+ Copyright (c) 2021-2023 Xiamen Yaji Software Co., Ltd.
+
+ http://www.cocos.com
+
+ 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 "SystemWindowManager.h"
+#include "SDL2/SDL_events.h"
+#include "platform/BasePlatform.h"
+#include "platform/SDLHelper.h"
+#include "platform/interfaces/modules/ISystemWindowManager.h"
+#include "platform/win32/modules/SystemWindow.h"
+
+namespace cc {
+
+int SystemWindowManager::init() {
+    return SDLHelper::init();
+}
+
+void SystemWindowManager::processEvent() {
+    SDL_Event sdlEvent;
+    while (SDL_PollEvent(&sdlEvent) != 0) {
+        SDL_Window *sdlWindow = SDL_GetWindowFromID(sdlEvent.window.windowID);
+        // SDL_Event like SDL_QUIT does not associate a window
+        if (!sdlWindow) {
+            SDLHelper::dispatchSDLEvent(0, sdlEvent);
+        } else {
+            ISystemWindow *window = getWindowFromSDLWindow(sdlWindow);
+            CC_ASSERT(window);
+            uint32_t windowId = window->getWindowId();
+            SDLHelper::dispatchSDLEvent(windowId, sdlEvent);
+        }
+    }
+}
+
+ISystemWindow *SystemWindowManager::createWindow(const ISystemWindowInfo &info) {
+    ISystemWindow *window = BasePlatform::getPlatform()->createNativeWindow(_nextWindowId, info.externalHandle);
+    if (window) {
+        if (!info.externalHandle) {
+            window->createWindow(info.title.c_str(), info.x, info.y, info.width, info.height, info.flags);
+        }
+        _windows[_nextWindowId] = std::shared_ptr<ISystemWindow>(window);
+        _nextWindowId++;
+    }
+    return window;
+}
+
+ISystemWindow *SystemWindowManager::getWindow(uint32_t windowId) const {
+    if (windowId == 0) {
+        return nullptr;
+    }
+
+    auto iter = _windows.find(windowId);
+    if (iter != _windows.end())
+        return iter->second.get();
+    return nullptr;
+}
+
+cc::ISystemWindow *SystemWindowManager::getWindowFromSDLWindow(SDL_Window *window) const {
+    for (const auto &iter : _windows) {
+        SystemWindow *sysWindow = static_cast<SystemWindow *>(iter.second.get());
+        SDL_Window *sdlWindow = sysWindow->getSDLWindow();
+        if (sdlWindow == window) {
+            return sysWindow;
+        }
+    }
+    return nullptr;
+}
+
+} // namespace cc

cocos/platform/win32/modules/SystemWindowManager.h

@@ -0,0 +1,54 @@
+/****************************************************************************
+ Copyright (c) 2021-2023 Xiamen Yaji Software Co., Ltd.
+
+ http://www.cocos.com
+
+ 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.
+****************************************************************************/
+
+#pragma once
+
+#include "base/std/container/unordered_map.h"
+#include "platform/interfaces/modules/ISystemWindowManager.h"
+
+struct SDL_Window;
+
+namespace cc {
+
+class ISystemWindow;
+
+class SystemWindowManager : public ISystemWindowManager {
+public:
+    SystemWindowManager() = default;
+
+    int init() override;
+    void processEvent() override;
+
+    ISystemWindow *createWindow(const ISystemWindowInfo &info) override;
+    ISystemWindow *getWindow(uint32_t windowId) const override;
+    const SystemWindowMap &getWindows() const override { return _windows; }
+
+    ISystemWindow *getWindowFromSDLWindow(SDL_Window *window) const;
+
+private:
+    uint32_t _nextWindowId{1}; // start from 1, 0 means an invalid ID
+
+    SystemWindowMap _windows;
+};
+} // namespace cc

cocos/platform/win32/modules/Vibrator.cpp

@@ -0,0 +1,35 @@
+/****************************************************************************
+ Copyright (c) 2021-2023 Xiamen Yaji Software Co., Ltd.
+
+ http://www.cocos.com
+
+ 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 "platform/win32/modules/Vibrator.h"
+
+#include "base/Macros.h"
+
+namespace cc {
+
+void Vibrator::vibrate(float duration) {
+    CC_UNUSED_PARAM(duration);
+}
+
+} // namespace cc

cocos/platform/win32/modules/Vibrator.h

@@ -0,0 +1,43 @@
+/****************************************************************************
+ Copyright (c) 2021-2023 Xiamen Yaji Software Co., Ltd.
+
+ http://www.cocos.com
+
+ 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.
+****************************************************************************/
+
+#pragma once
+
+#include "platform/interfaces/modules/IVibrator.h"
+
+namespace cc {
+
+class CC_DLL Vibrator : public IVibrator {
+public:
+    /**
+     * Vibrate for the specified amount of time.
+     * If vibrate is not supported, then invoking this method has no effect.
+     * Some platforms limit to a maximum duration of 5 seconds.
+     * Duration is ignored on iOS due to API limitations.
+     * @param duration The duration in seconds.
+     */
+    void vibrate(float duration) override;
+};
+
+} // namespace cc