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/Menu.cpp

@@ -34,6 +34,8 @@ THE SOFTWARE.
 #include "axmol/base/text_utils.h"
 #include "axmol/platform/StdC.h"
 
+#include <cmath>
+#include <limits>
 #include <vector>
 
 using namespace std;
@@ -46,6 +48,40 @@ enum
     kDefaultPadding = 5,
 };
 
+static bool hitTestNodeWithPointer(PointerEvent* event, const Camera* camera, Node* node, Vec3* outLocalHit)
+{
+    if (!event || !camera || !node)
+        return false;
+
+    Rect rect;
+    rect.size = node->getContentSize();
+    if (rect.size.width <= 0.0f || rect.size.height <= 0.0f)
+        return false;
+
+    if (event->hasRay())
+    {
+        Ray localRay(event->getRay().value());
+        localRay.transform(node->getWorldToNodeTransform());
+
+        if (std::abs(localRay.direction.z) <= std::numeric_limits<float>::epsilon())
+            return false;
+
+        const float t = -localRay.origin.z / localRay.direction.z;
+        if (t < 0.0f)
+            return false;
+
+        Vec3 localHit = localRay.origin + t * localRay.direction;
+        if (!rect.containsPoint(Vec2(localHit.x, localHit.y)))
+            return false;
+
+        if (outLocalHit)
+            *outLocalHit = localHit;
+        return true;
+    }
+
+    return camera->isWorldPointInRect(event->getLocation(), node->getWorldToNodeTransform(), rect, outLocalHit);
+}
+
 //
 // CCMenu
 //
@@ -228,7 +264,8 @@ bool Menu::onPointerHitTest(PointerEvent* event, const Camera* camera, Vec3* out
     if (!event || !camera)
         return false;
 
-    if (!event->isPrimaryPressed())
+    const bool isControllerRay = event->getPointerType() == PointerType::Controller && event->hasRay();
+    if (!event->isPrimaryPressed() && !isControllerRay)
         return false;
 
     if (_state != Menu::State::WAITING || !_visible || !_enabled)
@@ -576,18 +613,24 @@ void Menu::alignItemsInRowsWithArray(const ValueVector& columns)
 
 MenuItem* Menu::hitTestItem(PointerEvent* event, const Camera* camera, Vec3* outHitPoint)
 {
-    Vec2 touchLocation = event->getLocation();
     for (const auto& item : _children)
     {
         MenuItem* child = dynamic_cast<MenuItem*>(item);
         if (!child || !child->isVisible() || !child->isEnabled())
         {
             continue;
         }
-        Rect rect;
-        rect.size = child->getContentSize();
-        if (camera->isWorldPointInRect(touchLocation, child->getWorldToNodeTransform(), rect, outHitPoint))
+
+        Vec3 childLocalHit;
+        if (hitTestNodeWithPointer(event, camera, child, &childLocalHit))
         {
+            if (outHitPoint)
+            {
+                Vec3 worldHit = childLocalHit;
+                child->getNodeToWorldTransform().transformPoint(&worldHit);
+                *outHitPoint = worldHit;
+                getWorldToNodeTransform().transformPoint(outHitPoint);
+            }
             return child;
         }
     }

axmol/2d/NodeGrid.cpp

@@ -84,11 +84,11 @@ Camera* NodeGrid::getGridCamera()
 {
     if (!_gridCamera)
     {
-        _gridCamera = Camera::createCanvasOrthographic(-1, 1);
+        _gridCamera = Camera::createOrthographicView(_director->getCanvasSize(), -1, 1);
         AX_SAFE_RETAIN(_gridCamera);
     }
 
-    _gridCamera->initCanvasOrthographic(-1, 1);
+    _gridCamera->initOrthographicView(_director->getCanvasSize(), -1, 1);
     _gridCamera->setAdditionalTransform(Mat4::identity);
 
     auto visitingCamera = Camera::getVisitingCamera();

axmol/2d/Transition.cpp

@@ -1124,7 +1124,7 @@ void TransitionCrossFade::onEnter()
     Vec2 size         = _director->getCanvasSize();
     LayerColor* layer = LayerColor::create(color);
 
-    auto camera = Camera::createCanvasOrthographic(-1024, 1024);
+    auto camera = Camera::createOrthographicView(_director->getCanvasSize(), -1024, 1024);
 
     // create the first render texture for inScene
     RenderTexture* inTexture =

axmol/2d/TransitionProgress.cpp

@@ -79,7 +79,7 @@ void TransitionProgress::onEnter()
     sprite->setAnchorPoint(Vec2(0.5f, 0.5f));
 
     // render outScene to its texturebuffer
-    auto camera = Camera::createCanvasOrthographic(-1024, 1024);
+    auto camera = Camera::createOrthographicView(_director->getCanvasSize(), -1024, 1024);
 
     {
         RefPtr<RenderTexturePass> pass(RenderTexturePass::obtain(texture), tlx::adopt_object);

axmol/3d/Terrain.cpp

@@ -29,6 +29,7 @@ THE SOFTWARE.
 using namespace ax;
 #include <stdlib.h>
 #include <float.h>
+#include <limits>
 #include <set>
 #include <stddef.h>  // offsetof
 #include "axmol/renderer/Renderer.h"
@@ -38,6 +39,7 @@ using namespace ax;
 #include "axmol/rhi/Buffer.h"
 #include "axmol/base/Director.h"
 #include "axmol/base/Types.h"
+#include "axmol/base/PointerEvent.h"
 #include "axmol/tlx/vector.hpp"
 #include "axmol/tlx/utility.hpp"
 #include "axmol/base/EventType.h"
@@ -507,6 +509,49 @@ ax::Vec3 Terrain::getIntersectionPoint(const Ray& ray) const
     }
 }
 
+bool Terrain::onPointerHitTest(PointerEvent* event, const Camera* camera, Vec3* outHitPoint)
+{
+    if (!event || !camera || !isVisible())
+        return false;
+
+    Ray ray = event->hasRay() ? event->getRay().value() : camera->screenToRay(event->getScreenLocation());
+    if (event->hasRay())
+    {
+        auto sourceCamera = Camera::getDefaultCamera();
+        if (sourceCamera && sourceCamera != camera)
+        {
+            ray.transform(sourceCamera->getWorldToNodeTransform());
+            ray.transform(camera->getNodeToWorldTransform());
+        }
+    }
+    Vec3 hitPoint;
+   
+    bool hitted = getIntersectionPoint(ray, hitPoint);
+    if (event->getPhase() == InputPhase::PointerDown)
+    {
+        AXLOGI("Terrain::onPointerHitTest: ray origin: ({}, {}, {}), direction: ({}, {}, {}), hitted: {}, camera: {}", ray.origin.x,
+               ray.origin.y, ray.origin.z, ray.direction.x, ray.direction.y, ray.direction.z, hitted, (void*)camera);
+    }
+    if (!hitted)
+        return false;
+
+    if (outHitPoint)
+    {
+        Vec3 worldHitPoint = hitPoint;
+        getNodeToWorldTransform().transformPoint(&worldHitPoint);
+
+        auto distanceToRaySq = [&ray](const Vec3& point) {
+            const float distance = (point - ray.origin).dot(ray.direction);
+            const Vec3 closest   = ray.origin + ray.direction * distance;
+            return closest.distanceSquared(point);
+        };
+
+        *outHitPoint = distanceToRaySq(worldHitPoint) < distanceToRaySq(hitPoint) ? worldHitPoint : hitPoint;
+    }
+
+    return true;
+}
+
 bool Terrain::getIntersectionPoint(const Ray& ray_, Vec3& intersectionPoint) const
 {
     // convert ray from world space to local space

axmol/3d/Terrain.h

@@ -415,6 +415,8 @@ class AX_DLL Terrain : public Node
 
     // Overrides, internal use only
     void draw(ax::Renderer* renderer, const ax::Mat4& transform, uint32_t flags) override;
+    bool onPointerHitTest(PointerEvent* event, const Camera* camera, Vec3* outHitPoint) override;
+
     /**
      * Ray-Terrain intersection.
      * @return the intersection point