Squash commits

Author: halx99

.gitignore

@@ -209,17 +209,13 @@ temp/
 # ignore downloaded tools
 tools/external
 
-# ignore lua-tests res folder which is copy from cpp-tests
-tests/lua-tests/res/
-
 extensions/sceneio21
 extensions/sceneio20
 extensions/sceneio19
 extensions/fonteng
 
 tools/bindings-generator/clang/prebuilt/*
 
-templates/lua-template-default/Content/src/axmol
 tests/lua-tests/Content/src/axmol
 tests/lua-tests/Content/res
 tests/cpp-tests/Content
@@ -242,4 +238,4 @@ release_note_draft.txt
 1k/.env
 1k/llvm.sh
 
-.mimo*
+.mimo*

1k/build.profiles

@@ -97,7 +97,7 @@ emsdk=3.1.73~6.0.1+
 oboe=1.10.0
 kcp=2.1.1
 lz4=v1.10.0
-sample-assets=v3.0.0-alpha22
+sample-assets=master
 live2d-core=5.5
 openxr=release-1.1.61
 tracy=v0.13.1

CMakeLists.txt

@@ -27,7 +27,7 @@
 
 # build engine library and all tests
 
-cmake_minimum_required(VERSION 3.22...4.3)
+cmake_minimum_required(VERSION 3.22...4.4)
 
 project(axmol)
 

axmol/rhi/RenderContext.cpp

@@ -26,12 +26,33 @@
 #include "axmol/rhi/RenderContext.h"
 #include "axmol/rhi/PipelineDesc.h"
 #include "axmol/rhi/RenderTarget.h"
+#include "axmol/rhi/RHIUtils.h"
+#include "axmol/rhi/Texture.h"
 
 #include <limits>
 
 namespace ax::rhi
 {
 
+bool RenderContext::validateTextureCopy(const Texture* src, const Texture* dst)
+{
+    if (!src || !dst || src == dst)
+        return false;
+
+    if (src->getTextureType() != TextureType::TEXTURE_2D || dst->getTextureType() != TextureType::TEXTURE_2D ||
+        src->getArraySize() != 1 || dst->getArraySize() != 1 || src->getMipLevels() != 1 || dst->getMipLevels() != 1 ||
+        src->getWidth() <= 0 || src->getHeight() <= 0 || src->getWidth() != dst->getWidth() ||
+        src->getHeight() != dst->getHeight() || src->getPixelFormat() != dst->getPixelFormat())
+        return false;
+
+    const auto format = src->getPixelFormat();
+    if (format == PixelFormat::NONE || format == PixelFormat::D24S8)
+        return false;
+
+    const auto& formatDesc = RHIUtils::getFormatDesc(format);
+    return formatDesc.blockWidth == 1 && formatDesc.blockHeight == 1;
+}
+
 RenderContext::~RenderContext() {}
 
 void RenderContext::updatePipelineState(const RenderTarget* rt,

axmol/rhi/RenderContext.h

@@ -228,6 +228,35 @@ class RenderContext : public ax::Object
      */
     virtual void readPixels(RenderTarget* rt, std::function<void(const PixelBufferDesc&)> callback) = 0;
 
+    /**
+     * @brief Copies the contents of one texture resource into another texture resource.
+     *
+     * This operation performs a GPU-side texture copy without involving the CPU.
+     * The source and destination textures must be compatible for copying according
+     * to the underlying graphics backend requirements.
+     *
+     * @param src Source texture to copy from.
+     * @param dst Destination texture to copy into.
+     *
+     * @return true if the copy command was successfully issued; otherwise false.
+     */
+    virtual bool copyTexture(Texture* src, Texture* dst) = 0;
+
+    /**
+     * @brief Copies the rendered contents of a render target into a texture resource.
+     *
+     * Unlike texture-to-texture copies, this operation copies from the current
+     * render target output. The underlying implementation may use a framebuffer
+     * copy, resolve, or other backend-specific operation depending on the graphics
+     * API.
+     *
+     * @param src Source render target.
+     * @param dst Destination texture to receive the rendered contents.
+     *
+     * @return true if the copy command was successfully issued; otherwise false.
+     */
+    virtual bool copyTexture(RenderTarget* src, Texture* dst) = 0;
+
     /**
      * This property controls whether or not the drawables'
      * metal textures may only be used for framebuffer attachments (YES) or
@@ -254,6 +283,8 @@ class RenderContext : public ax::Object
      */
     virtual uint64_t getCompletedFenceValue() const;
 
+    static bool validateTextureCopy(const Texture* src, const Texture* dst);
+
 protected:
     virtual ~RenderContext();
 

axmol/rhi/RenderTarget.cpp

@@ -87,4 +87,21 @@ void RenderTarget::setDepthStencilTexture(Texture* texture, int level)
     }
 }
 
+PixelFormat RenderTarget::getColorAttachmentPixelFormat(int index) const
+{
+    if (_defaultRenderTarget && index != 0)
+        return PixelFormat::NONE;
+
+    if (index < 0 || index >= static_cast<int>(_color.size()))
+        return PixelFormat::NONE;
+
+    const auto& color = _color[index];
+    return color.texture ? color.texture->getPixelFormat() : PixelFormat::NONE;
+}
+
+PixelFormat RenderTarget::getDepthStencilAttachmentPixelFormat() const
+{
+    return _depthStencil.texture ? _depthStencil.texture->getPixelFormat() : PixelFormat::NONE;
+}
+
 }  // namespace ax::rhi

axmol/rhi/RenderTarget.h

@@ -67,6 +67,9 @@ class RenderTarget : public ax::Object
     virtual void setColorTexture(Texture* texture, int level = 0, int index = 0);
     virtual void setDepthStencilTexture(Texture* texture, int level = 0);
 
+    virtual PixelFormat getColorAttachmentPixelFormat(int index = 0) const;
+    virtual PixelFormat getDepthStencilAttachmentPixelFormat() const;
+
     bool isDirty() const { return !!_dirtyFlags; }
 
     ColorAttachment _color{};

axmol/rhi/Texture.h

@@ -82,6 +82,8 @@ class Texture : public Object
 
     int getWidth() const { return static_cast<int>(_desc.width); }
     int getHeight() const { return static_cast<int>(_desc.height); }
+    int getArraySize() const { return static_cast<int>(_desc.arraySize); }
+    int getMipLevels() const { return static_cast<int>(_desc.mipLevels); }
 
     /**
      * Update a two-dimensional texture image

axmol/rhi/d3d11/RenderContext11.cpp

@@ -851,4 +851,69 @@ void RenderContextImpl::readPixels(RenderTarget* rt, UINT x, UINT y, UINT width,
     SafeRelease(stagingTex);
 }
 
+bool RenderContextImpl::copyTexture(Texture* src, Texture* dst)
+{
+    if (!validateTextureCopy(src, dst))
+        return false;
+
+    auto* srcImpl = static_cast<TextureImpl*>(src);
+    auto* dstImpl = static_cast<TextureImpl*>(dst);
+
+    auto* srcResource = srcImpl->internalHandle().resource;
+    if (!srcResource)
+        return false;
+
+    if (!dstImpl->internalHandle().resource)
+        dstImpl->updateData(nullptr, dst->getWidth(), dst->getHeight(), 0, 0);
+
+    auto* dstResource = dstImpl->internalHandle().resource;
+    if (!dstResource || srcResource == dstResource)
+        return false;
+
+    D3D11_TEXTURE2D_DESC srcDesc{};
+    D3D11_TEXTURE2D_DESC dstDesc{};
+    srcResource->GetDesc(&srcDesc);
+    dstResource->GetDesc(&dstDesc);
+
+    if (srcDesc.Width != dstDesc.Width || srcDesc.Height != dstDesc.Height || srcDesc.Format != dstDesc.Format ||
+        srcDesc.SampleDesc.Count != 1 || dstDesc.SampleDesc.Count != 1 || srcDesc.ArraySize != 1 ||
+        dstDesc.ArraySize != 1 || srcDesc.MipLevels != 1 || dstDesc.MipLevels != 1 ||
+        dstDesc.Usage != D3D11_USAGE_DEFAULT)
+        return false;
+
+    // D3D11 keeps the last render targets bound after endRenderPass(). Temporarily
+    // unbind them so a just-rendered color attachment can be used as a copy source.
+    ID3D11RenderTargetView* oldRTVs[D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT]{};
+    ID3D11DepthStencilView* oldDSV = nullptr;
+    _d3d11Context->OMGetRenderTargets(D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT, oldRTVs, &oldDSV);
+    _d3d11Context->OMSetRenderTargets(0, nullptr, nullptr);
+
+    _d3d11Context->CopySubresourceRegion(dstResource, 0, 0, 0, 0, srcResource, 0, nullptr);
+
+    UINT oldRTVCount = 0;
+    for (UINT i = 0; i < D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT; ++i)
+    {
+        if (oldRTVs[i])
+            oldRTVCount = i + 1;
+    }
+    _d3d11Context->OMSetRenderTargets(oldRTVCount, oldRTVs, oldDSV);
+    for (auto* rtv : oldRTVs)
+        SafeRelease(rtv);
+    SafeRelease(oldDSV);
+
+    return true;
+}
+
+bool RenderContextImpl::copyTexture(RenderTarget* src, Texture* dst)
+{
+    if (!src || !dst || src->_color.empty())
+        return false;
+
+    const auto& color = src->_color[0];
+    if (color.level != 0 || !color.texture)
+        return false;
+
+    return copyTexture(color.texture, dst);
+}
+
 }  // namespace ax::rhi::d3d11

axmol/rhi/d3d11/RenderContext11.h

@@ -132,6 +132,9 @@ class RenderContextImpl : public RenderContext
 
     void readPixels(RenderTarget* rt, std::function<void(const PixelBufferDesc&)> callback) override;
 
+    bool copyTexture(RenderTarget* src, Texture* dst) override;
+    bool copyTexture(Texture* src, Texture* dst) override;
+
 protected:
     void readPixels(RenderTarget* rt, UINT x, UINT y, UINT width, UINT height, PixelBufferDesc& pbd);