Squash commits

Author: halx99

1k/build.profiles

@@ -99,4 +99,5 @@ kcp=2.1.1
 lz4=v1.10.0
 sample-assets=master
 live2d-core=5.5
+openxr=release-1.1.60
 # --- endregion

1k/fetch.ps1

@@ -207,15 +207,18 @@ if (!(Test-Path "$lib_src/.git" -PathType Container)) { $is_git_repo = $false }
 
 # checkout revision for git repo
 if (!$revision) {
-    # regard v as tag or doesn't ends with short git hash
-    if ($version.StartsWith('v')) {
-        $revision = $version
+    # Treat versions ending with "-<git-hash>" as pinned commits, for example:
+    #   1.2.3-a1b2c3d
+    #   release-1.2.3-a1b2c3d4e5f6
+    # Other names, including "v1.2.3", "release-1.2.3" and custom tag/branch names,
+    # are passed through as-is and resolved by git below.
+    $match_info = [Regex]::Match($version, '^(.*)-([0-9a-fA-F]{7,40})$')
+    if ($match_info.Success) {
+        $version  = $match_info.Groups[1].Value
+        $revision = $match_info.Groups[2].Value
     }
     else {
-        $ver_pair = [array]$version.Split('-')
-        $use_hash = $ver_pair.Count -gt 1
-        $revision = $ver_pair[$use_hash].Trim()
-        $version = $ver_pair[0]
+        $revision = $version
     }
 }
 

1k/sources.json

@@ -28,6 +28,9 @@
         "gitee": "https://gitee.com/simdsoft/lz4.git"
       }
     },
+    "openxr": {
+      "sources": { "origin": "https://github.com/KhronosGroup/OpenXR-SDK.git" }
+    },
     "sample-assets": {
       "sources": {
         "origin": "https://github.com/axmolengine/axmol-sample-assets.git",

3rdparty/CMakeLists.txt

@@ -140,6 +140,9 @@ if(ANDROID)
 endif()
 
 ax_add_3rd(fmt)
+if (TARGET fmt-c)
+  set_target_properties(fmt-c PROPERTIES FOLDER "3rdparty")
+endif()
 
 # bellow are non header only libs
 
@@ -427,6 +430,12 @@ ax_add_3rd(yasio)
 # simdjson
 ax_add_3rd(simdjson)
 
+# openxr
+if (AX_ENABLE_OPENXR)
+  _1kfetch(openxr)
+  ax_add_3rd(${openxr_SOURCE_DIR} TARGETS openxr_loader)
+endif()
+
 if(ANDROID)
   function(config_android_shared_libs package_name target_folder)
     string(REPLACE "." "/" package_path ${package_name})

axmol/2d/Grid.cpp

@@ -31,15 +31,63 @@ THE SOFTWARE.
 #include "axmol/base/Utils.h"
 #include "axmol/scene/Node.h"
 #include "axmol/renderer/Renderer.h"
+#include "axmol/renderer/RenderTexturePass.h"
 #include "axmol/renderer/Texture2D.h"
 #include "axmol/renderer/Shaders.h"
 #include "axmol/rhi/ProgramState.h"
 #include "axmol/rhi/RenderTarget.h"
 #include "axmol/rhi/DriverContext.h"
 #include "axmol/scene/Camera.h"
+#include "axmol/math/Vec4.h"
+
+#include <cmath>
 
 namespace ax
 {
+
+static constexpr float GRID_BLIT_ORDER = RT_PASS_END_ORDER - 1;
+
+static bool projectGridPointToCanvas(const Mat4& projection, const Vec3& point, const Vec2& size, Vec2& out)
+{
+    if (size.width <= 0.0f || size.height <= 0.0f)
+        return false;
+
+    Vec4 clip(point.x, point.y, point.z, 1.0f);
+    projection.transformVector(&clip);
+
+    if (std::abs(clip.w) <= 0.000001f)
+        return false;
+
+    const float ndcX = clip.x / clip.w;
+    const float ndcY = clip.y / clip.w;
+    out.set((ndcX + 1.0f) * 0.5f * size.width, (ndcY + 1.0f) * 0.5f * size.height);
+    return true;
+}
+
+static Vec2 projectGridTexCoordToCanvas(const Mat4& projection,
+                                        const Vec3& point,
+                                        const Vec2& size,
+                                        bool flipped,
+                                        const Vec2& fallbackUV)
+{
+    Vec2 projected;
+    if (!projectGridPointToCanvas(projection, point, size, projected))
+        return fallbackUV;
+
+    Vec2 uv(projected.x / size.width, projected.y / size.height);
+    if (flipped)
+        uv.y = 1.0f - uv.y;
+    return uv;
+}
+
+static Vec3 projectGridVertexToCanvas(const Mat4& projection, const Vec3& point, const Vec2& size)
+{
+    Vec2 projected;
+    if (projectGridPointToCanvas(projection, point, size, projected))
+        return Vec3(projected.x, projected.y, 0.0f);
+
+    return point;
+}
 // implementation of GridBase
 
 bool GridBase::initWithSize(const Vec2& gridSize)
@@ -157,40 +205,29 @@ void GridBase::setGridRect(const ax::Rect& rect)
 
 void GridBase::beforeDraw()
 {
-    Director* director = Director::getInstance();
-
-    auto* renderer     = director->getRenderer();
-    auto* groupCommand = renderer->getNextGroupCommand();
-    groupCommand->init(0);
-    renderer->addCommand(groupCommand);
-    renderer->pushGroup(groupCommand->getRenderQueueID());
+    AX_SAFE_RELEASE(_renderTarget);
+    _renderTarget = axdrv->createRenderTarget(_texture->getRHITexture());
 
-    auto beforeDrawCommandFunc = [director, renderer, this]() -> void {
-        Vec2 size = director->getCanvasSizeInPixels();
-        renderer->setViewport(0, 0, (unsigned int)size.width, (unsigned int)size.height);
+    if (!_renderTexturePass)
+    {
+        _renderTexturePass = RefPtr<RenderTexturePass>(RenderTexturePass::obtain(), tlx::adopt_object);
+        _renderTexturePass->setCameraOverrideEnabled(false);
+    }
 
-        _oldRenderTarget = renderer->getRenderTarget();
-        AX_SAFE_RELEASE(_renderTarget);
-        _renderTarget = axdrv->createRenderTarget(_texture->getRHITexture());
-        renderer->setRenderTarget(_renderTarget);
-    };
-    renderer->addCallbackCommand(beforeDrawCommandFunc);
+    _renderTexturePass->setTarget(_renderTarget);
+    _renderTexturePass->setViewport(
+        Viewport(0, 0, static_cast<int>(_texture->getWidth()), static_cast<int>(_texture->getHeight())));
+    _renderTexturePass->begin();
 
-    // since we use clearCommand, should call at here to avoid iterator damage
-    renderer->clear(TargetBufferFlags::COLOR, _clearColor, 1, 0, 0.0);
+    _renderTexturePass->clear(ClearFlag::COLOR, {.color = _clearColor, .depth = 1.0f, .stencil = 0});
 }
 
 void GridBase::afterDraw(ax::Node* /*target*/)
 {
     auto renderer = Director::getInstance()->getRenderer();
 
-    renderer->addCallbackCommand([renderer, this]() -> void {
-        const auto& vp = Camera::getDefaultViewport();
-        renderer->setViewport(vp.x, vp.y, vp.width, vp.height);
-        renderer->setRenderTarget(_oldRenderTarget);
-    });
-
-    renderer->popGroup();
+    if (_renderTexturePass && _renderTexturePass->isActive())
+        _renderTexturePass->end();
 
     renderer->addCallbackCommand([this]() -> void { beforeBlit(); });
 
@@ -199,6 +236,16 @@ void GridBase::afterDraw(ax::Node* /*target*/)
     renderer->addCallbackCommand([this]() -> void { afterBlit(); });
 }
 
+void GridBase::setScreenProjectionForBlit(const Mat4* projection, const Vec2& size)
+{
+    _screenProjectionForBlitEnabled = projection && size.width > 0.0f && size.height > 0.0f;
+    if (_screenProjectionForBlitEnabled)
+    {
+        _screenProjectionForBlit     = *projection;
+        _screenProjectionForBlitSize = size;
+    }
+}
+
 // implementation of Grid3D
 
 Grid3D* Grid3D::create(const Vec2& gridSize)
@@ -305,9 +352,10 @@ void Grid3D::afterBlit()
 void Grid3D::blit()
 {
     updateVertexBuffer();
-    _drawCommand.init(0, _blendFunc);
+    _drawCommand.init(GRID_BLIT_ORDER, _blendFunc);
     Director::getInstance()->getRenderer()->addCommand(&_drawCommand);
-    ax::Mat4 projectionMat = Camera::getVisitingViewProjectionMatrix();
+    auto camera            = Camera::getVisitingCamera();
+    ax::Mat4 projectionMat = camera ? camera->getVisitingViewProjectionMatrix() : Mat4::identity;
     auto programState      = _drawCommand.unsafePS();
     programState->setUniform(_mvpMatrixLocation, projectionMat.m, sizeof(projectionMat.m));
     programState->setTexture(_textureLocation, 0, _texture->getRHITexture());
@@ -446,12 +494,28 @@ void Grid3D::reuse()
 
 void Grid3D::updateVertexBuffer()
 {
-    size_t numOfPoints  = static_cast<size_t>((_gridSize.width + 1) * (_gridSize.height + 1));
-    auto tempVecPointer = (Vec3*)_vertices;
+    size_t numOfPoints          = static_cast<size_t>((_gridSize.width + 1) * (_gridSize.height + 1));
+    auto tempVecPointer         = (Vec3*)_vertices;
+    auto tempOriginalVecPointer = (Vec3*)_originalVertices;
+    auto tempTexPointer         = (Vec2*)_texCoordinates;
     for (size_t i = 0; i < numOfPoints; ++i)
     {
         auto offset = i * (sizeof(Vec3) + sizeof(Vec2));
-        memcpy((char*)_vertexBuffer + offset, &tempVecPointer[i], sizeof(Vec3));
+        if (_screenProjectionForBlitEnabled)
+        {
+            auto vertex =
+                projectGridVertexToCanvas(_screenProjectionForBlit, tempVecPointer[i], _screenProjectionForBlitSize);
+            auto texCoord =
+                projectGridTexCoordToCanvas(_screenProjectionForBlit, tempOriginalVecPointer[i],
+                                            _screenProjectionForBlitSize, _isTextureFlipped, tempTexPointer[i]);
+            memcpy((char*)_vertexBuffer + offset, &vertex, sizeof(Vec3));
+            memcpy((char*)_vertexBuffer + offset + sizeof(Vec3), &texCoord, sizeof(Vec2));
+        }
+        else
+        {
+            memcpy((char*)_vertexBuffer + offset, &tempVecPointer[i], sizeof(Vec3));
+            memcpy((char*)_vertexBuffer + offset + sizeof(Vec3), &tempTexPointer[i], sizeof(Vec2));
+        }
     }
     _drawCommand.updateVertexBuffer(_vertexBuffer,
                                     (unsigned int)(numOfPoints * sizeof(Vec3) + numOfPoints * sizeof(Vec2)));
@@ -561,9 +625,10 @@ TiledGrid3D* TiledGrid3D::create(const Vec2& gridSize, Texture2D* texture, bool
 void TiledGrid3D::blit()
 {
     updateVertexBuffer();
-    _drawCommand.init(0, _blendFunc);
+    _drawCommand.init(GRID_BLIT_ORDER, _blendFunc);
     Director::getInstance()->getRenderer()->addCommand(&_drawCommand);
-    ax::Mat4 projectionMat = Camera::getVisitingViewProjectionMatrix();
+    auto camera            = Camera::getVisitingCamera();
+    ax::Mat4 projectionMat = camera ? camera->getVisitingViewProjectionMatrix() : Mat4::identity;
     auto programState      = _drawCommand.unsafePS();
     programState->setUniform(_mvpMatrixLocation, projectionMat.m, sizeof(projectionMat.m));
     programState->setTexture(_textureLocation, 0, _texture->getRHITexture());
@@ -700,13 +765,29 @@ void TiledGrid3D::reuse()
 
 void TiledGrid3D::updateVertexBuffer()
 {
-    size_t gradSize     = static_cast<size_t>(_gridSize.width * _gridSize.height);
-    size_t numOfPoints  = gradSize * 4;
-    auto tempVecPointer = (Vec3*)_vertices;
+    size_t gradSize             = static_cast<size_t>(_gridSize.width * _gridSize.height);
+    size_t numOfPoints          = gradSize * 4;
+    auto tempVecPointer         = (Vec3*)_vertices;
+    auto tempOriginalVecPointer = (Vec3*)_originalVertices;
+    auto tempTexPointer         = (Vec2*)_texCoordinates;
     for (size_t i = 0; i < numOfPoints; ++i)
     {
         auto offset = i * (sizeof(Vec3) + sizeof(Vec2));
-        memcpy((char*)_vertexBuffer + offset, &tempVecPointer[i], sizeof(Vec3));
+        if (_screenProjectionForBlitEnabled)
+        {
+            auto vertex =
+                projectGridVertexToCanvas(_screenProjectionForBlit, tempVecPointer[i], _screenProjectionForBlitSize);
+            auto texCoord =
+                projectGridTexCoordToCanvas(_screenProjectionForBlit, tempOriginalVecPointer[i],
+                                            _screenProjectionForBlitSize, _isTextureFlipped, tempTexPointer[i]);
+            memcpy((char*)_vertexBuffer + offset, &vertex, sizeof(Vec3));
+            memcpy((char*)_vertexBuffer + offset + sizeof(Vec3), &texCoord, sizeof(Vec2));
+        }
+        else
+        {
+            memcpy((char*)_vertexBuffer + offset, &tempVecPointer[i], sizeof(Vec3));
+            memcpy((char*)_vertexBuffer + offset + sizeof(Vec3), &tempTexPointer[i], sizeof(Vec2));
+        }
     }
     _drawCommand.updateVertexBuffer(_vertexBuffer,
                                     (unsigned int)(numOfPoints * sizeof(Vec3) + numOfPoints * sizeof(Vec2)));

axmol/2d/Grid.h

@@ -28,6 +28,7 @@ THE SOFTWARE.
 #pragma once
 
 #include "axmol/base/Object.h"
+#include "axmol/base/RefPtr.h"
 #include "axmol/base/Types.h"
 #include "axmol/base/Director.h"
 #include "axmol/renderer/GroupCommand.h"
@@ -39,6 +40,8 @@ namespace ax
 
 class Texture2D;
 class Node;
+class NodeGrid;
+class RenderTexturePass;
 
 namespace rhi
 {
@@ -134,6 +137,13 @@ class AX_DLL GridBase : public Object
     const Rect& getGridRect() const { return _gridRect; }
 
 protected:
+    friend class NodeGrid;
+
+    /** Internal NodeGrid hook: project uploaded blit vertices/UVs through
+     *  the capture camera while still drawing with the grid ortho camera.
+     */
+    void setScreenProjectionForBlit(const Mat4* projection, const Vec2& size);
+
     void updateBlendState();
 
     bool _active   = false;
@@ -152,16 +162,19 @@ class AX_DLL GridBase : public Object
     // CallbackCommand _beforeBlitCommand;
     // CallbackCommand _afterBlitCommand;
 
-    // New
-    rhi::RenderTarget* _oldRenderTarget = nullptr;
-    rhi::RenderTarget* _renderTarget    = nullptr;
+    rhi::RenderTarget* _renderTarget = nullptr;
+    RefPtr<RenderTexturePass> _renderTexturePass;
 
     rhi::UniformLocation _mvpMatrixLocation;
     rhi::UniformLocation _textureLocation;
     rhi::ProgramState* _programState = nullptr;
     rhi::VertexLayout* _vertexLayout = nullptr;
 
     BlendFunc _blendFunc;
+
+    bool _screenProjectionForBlitEnabled = false;
+    Mat4 _screenProjectionForBlit        = Mat4::identity;
+    Vec2 _screenProjectionForBlitSize;
 };
 
 /**