tune bullet asm,wasm library performance (#355)

* update bullet library

* fix bullet.d.ts export

android/CMakeLists.txt

@@ -63,35 +63,6 @@ target_include_directories(android_platform PUBLIC
 #   android log dl
 # )
 
-if(USE_XR)
-  include(${CMAKE_CURRENT_LIST_DIR}/xr.cmake)
-  if(BUILD_XR_NATIVE)
-    list(APPEND XR_EXTERNAL_SOURCES ${CMAKE_CURRENT_LIST_DIR}/../../cocos/xr/Xr.h)
-    list(APPEND XR_EXTERNAL_SOURCES ${CMAKE_CURRENT_LIST_DIR}/../../cocos/platform/interfaces/modules/XRCommon.h)
-    list(APPEND XR_EXTERNAL_INCLUDES ${CMAKE_CURRENT_LIST_DIR}/../../cocos/xr)
-    list(APPEND XR_EXTERNAL_INCLUDES ${CMAKE_CURRENT_LIST_DIR}/../../cocos/platform/interfaces/modules)
-    include(${CMAKE_CURRENT_LIST_DIR}/../../../../CCOpenXR/internal/CMakeLists.txt)
-  else()
-    add_library(xr STATIC IMPORTED GLOBAL)
-    set_target_properties(xr PROPERTIES
-      IMPORTED_LOCATION ${platform_spec_path}/xr/${XR_FOLDER}/libxr.a
-      INTERFACE_INCLUDE_DIRECTORIES ${CMAKE_CURRENT_LIST_DIR}/../../cocos/xr
-    )
-
-    set_property(TARGET xr APPEND PROPERTY
-      INTERFACE_INCLUDE_DIRECTORIES ${CMAKE_CURRENT_LIST_DIR}/../../cocos/platform/interfaces/modules
-    )
-
-    target_link_libraries(xr INTERFACE
-      ${XR_EXTERNAL_LIBS}
-    )
-  endif()
-
-  list(APPEND CC_EXTERNAL_LIBS
-      xr
-  )
-endif()
-
 set(se_libs_name)
 
 if(USE_SE_V8)
@@ -160,17 +131,6 @@ else()
   set(PhysXSDK)
 endif()
 
-if(USE_AR_MODULE)
-  set(ARSDK libAR)
-  add_library(libAR STATIC IMPORTED GLOBAL)
-  set_target_properties(libAR PROPERTIES
-    IMPORTED_LOCATION ${platform_spec_path}/ar/libar.a
-    INTERFACE_INCLUDE_DIRECTORIES ${CMAKE_CURRENT_LIST_DIR}/../../cocos/xr
-  )
-else()
-  set(ARSDK)
-endif()
-
 if (USE_DEBUG_RENDERER)
 list(APPEND CC_EXTERNAL_LIBS
     freetype
@@ -184,7 +144,6 @@ list(APPEND CC_EXTERNAL_LIBS
     uv
     android_platform
     ${PhysXSDK}
-    ${ARSDK}
 )
 
 if(USE_JOB_SYSTEM_TBB OR CC_USE_VULKAN) ## VKDevice.cpp use tbb_allocator.h

android/xr.cmake

@@ -1,117 +0,0 @@
-
-
-################################# options ############################################
-# default fallback options
-cc_set_if_undefined(BUILD_XR_NATIVE               OFF)
-cc_set_if_undefined(XR_OEM_META                   OFF)
-cc_set_if_undefined(XR_OEM_HUAWEIVR               OFF)
-cc_set_if_undefined(XR_OEM_PICO                   OFF)
-cc_set_if_undefined(XR_OEM_ROKID                  OFF)
-cc_set_if_undefined(XR_OEM_SEED                   OFF)
-cc_set_if_undefined(XR_OEM_SNAPDRAGON_SPACES      OFF)
-cc_set_if_undefined(XR_USE_GRAPHICS_API_OPENGL_ES ON)
-cc_set_if_undefined(XR_USE_GRAPHICS_API_VULKAN    ON)
-cc_set_if_undefined(XR_USE_GRAPHICS_API_OPENGL    OFF)
-cc_set_if_undefined(XR_USE_GRAPHICS_API_D3D11     OFF)
-cc_set_if_undefined(XR_USE_GRAPHICS_API_D3D12     OFF)
-
-
-# Several files use these compile time platform switches
-if(WIN32)
-    cc_set_if_undefined(XR_USE_PLATFORM_WIN32     ON)
-elseif(ANDROID)
-    cc_set_if_undefined(XR_USE_PLATFORM_ANDROID   ON)
-elseif(PRESENTATION_BACKEND MATCHES "xlib")
-    cc_set_if_undefined(XR_USE_PLATFORM_XLIB      ON)
-elseif(PRESENTATION_BACKEND MATCHES "xcb")
-    cc_set_if_undefined(XR_USE_PLATFORM_XCB       ON)
-elseif(PRESENTATION_BACKEND MATCHES "wayland")
-    cc_set_if_undefined(XR_USE_PLATFORM_WAYLAND   ON)
-endif()
-
-
-################################# list all option values ##############################
-cc_inspect_values(
-    BUILD_XR_NATIVE
-    XR_OEM_META
-    XR_OEM_HUAWEIVR
-    XR_OEM_PICO
-    XR_OEM_ROKID
-    XR_OEM_SEED
-    XR_OEM_SNAPDRAGON_SPACES
-    XR_USE_GRAPHICS_API_OPENGL_ES
-    XR_USE_GRAPHICS_API_VULKAN
-    XR_USE_GRAPHICS_API_OPENGL
-    XR_USE_GRAPHICS_API_D3D11
-    XR_USE_GRAPHICS_API_D3D12
-    XR_USE_PLATFORM_WIN32
-    XR_USE_PLATFORM_ANDROID
-    XR_USE_PLATFORM_XLIB
-    XR_USE_PLATFORM_XCB
-    XR_USE_PLATFORM_WAYLAND
-)
-
-
-################################# cc_xr_apply_definations ###################################
-function(cc_xr_apply_definations target)
-    target_compile_definitions(${target} PUBLIC
-        $<IF:$<BOOL:${XR_OEM_META}>,XR_OEM_META=1,XR_OEM_META=0>
-        $<IF:$<BOOL:${XR_OEM_HUAWEIVR}>,XR_OEM_HUAWEIVR=1,XR_OEM_HUAWEIVR=0>
-        $<IF:$<BOOL:${XR_OEM_PICO}>,XR_OEM_PICO=1,XR_OEM_PICO=0>
-        $<IF:$<BOOL:${XR_OEM_ROKID}>,XR_OEM_ROKID=1,XR_OEM_ROKID=0>
-        $<IF:$<BOOL:${XR_OEM_SEED}>,XR_OEM_SEED=1,XR_OEM_SEED=0>
-        $<IF:$<BOOL:${XR_OEM_SNAPDRAGON_SPACES}>,XR_OEM_SNAPDRAGON_SPACES=1,XR_OEM_SNAPDRAGON_SPACES=0>
-        $<$<BOOL:${XR_USE_GRAPHICS_API_OPENGL_ES}>:XR_USE_GRAPHICS_API_OPENGL_ES=1>
-        $<$<BOOL:${XR_USE_GRAPHICS_API_VULKAN}>:XR_USE_GRAPHICS_API_VULKAN=1>
-        $<$<BOOL:${XR_USE_GRAPHICS_API_OPENGL}>:XR_USE_GRAPHICS_API_OPENGL=1>
-        $<$<BOOL:${XR_USE_GRAPHICS_API_D3D11}>:XR_USE_GRAPHICS_API_D3D11=1>
-        $<$<BOOL:${XR_USE_GRAPHICS_API_D3D12}>:XR_USE_GRAPHICS_API_D3D12=1>
-        $<$<BOOL:${XR_USE_PLATFORM_WIN32}>:XR_USE_PLATFORM_WIN32=1>
-        $<$<BOOL:${XR_USE_PLATFORM_ANDROID}>:XR_USE_PLATFORM_ANDROID=1>
-        $<$<BOOL:${XR_USE_PLATFORM_XLIB}>:XR_USE_PLATFORM_XLIB=1>
-        $<$<BOOL:${XR_USE_PLATFORM_XCB}>:XR_USE_PLATFORM_XCB=1>
-        $<$<BOOL:${XR_USE_PLATFORM_WAYLAND}>:XR_USE_PLATFORM_WAYLAND=1>
-    )
-endfunction()
-
-set(XR_EXTERNAL_LIBS)
-set(XR_EXTERNAL_INCLUDES)
-set(XR_EXTERNAL_SOURCES)
-
-list(APPEND XR_EXTERNAL_INCLUDES
-        ${CMAKE_CURRENT_LIST_DIR}
-)
-
-set(XR_OEM_LOADER_NAME openxr_loader)
-if(XR_OEM_META)
-    set(XR_OEM_FOLDER meta)
-    set(XR_FOLDER meta)
-elseif(XR_OEM_HUAWEIVR)
-    set(XR_OEM_FOLDER huaweivr)
-    set(XR_OEM_LOADER_NAME xr_loader)
-    set(XR_FOLDER huaweivr)
-elseif(XR_OEM_PICO)
-    set(XR_OEM_FOLDER pico)
-    set(XR_FOLDER pico)
-elseif(XR_OEM_ROKID)
-    set(XR_OEM_FOLDER rokid)
-    set(XR_FOLDER rokid)
-elseif(XR_OEM_SEED)
-    set(XR_OEM_FOLDER monado)
-    set(XR_FOLDER seed)
-elseif(XR_OEM_SNAPDRAGON_SPACES)
-    set(XR_OEM_FOLDER spaces)
-    set(XR_FOLDER spaces)
-else()
-    set(XR_OEM_FOLDER monado)
-    set(XR_FOLDER monado)
-endif()
-
-add_library(openxr SHARED IMPORTED GLOBAL)
-set_target_properties(openxr PROPERTIES
-  IMPORTED_LOCATION ${platform_spec_path}/xr/${XR_OEM_FOLDER}/lib${XR_OEM_LOADER_NAME}.so
-)
-
-list(APPEND XR_EXTERNAL_LIBS
-    openxr
-)

emscripten/bullet/bullet.d.ts

@@ -0,0 +1,284 @@
+declare module 'external:emscripten/bullet/bullet.asm.js' {
+    function factory (env: any, wasmMemory: ArrayBuffer): Bullet.instance;
+    export default factory;
+}
+
+declare namespace Bullet {
+    type ptr = number;
+    interface instance {
+        _malloc(bytes: number): ptr;
+        _free(p: ptr): void;
+        _read_f32(p: ptr): void;
+        _write_f32(p: ptr, v: number): void;
+        _safe_delete(p: ptr, bulletType: number): void;
+
+        Vec3_new(x: number, y: number, z: number): ptr;
+        Vec3_x(p: ptr): number;
+        Vec3_y(p: ptr): number;
+        Vec3_z(p: ptr): number;
+        Vec3_set(p: ptr, x: number, y: number, z: number): void;
+
+        Quat_new(x: number, y: number, z: number, w: number): ptr;
+        Quat_x(p: ptr): number;
+        Quat_y(p: ptr): number;
+        Quat_z(p: ptr): number;
+        Quat_w(p: ptr): number;
+        Quat_set(p: ptr, x: number, y: number, z: number, w: number): void;
+
+        Transform_new(): ptr;
+        Transform_setIdentity(p: ptr): void;
+        Transform_getOrigin(p: ptr): ptr;
+        Transform_setRotation(p: ptr, quate: ptr): void;
+        Transform_getRotation(p: ptr, quate: ptr): void;
+
+        MotionState_getWorldTransform(p: ptr, transform: ptr): void;
+        MotionState_setWorldTransform(p: ptr, transform: ptr): void;
+        ccMotionState_new(id: number, initTrans: ptr): ptr;
+
+        int_array_size(p: ptr): number;
+        int_array_at(p: ptr, index: number): number;
+        Vec3_array_at(p: ptr, index: number): ptr;
+
+        // constraints
+
+        TypedConstraint_getFixedBody(): ptr;
+        HingeConstraint_new(ptr0: ptr, ptr1: ptr, ptr2: ptr, ptr3: ptr): ptr;
+        HingeConstraint_setFrames(ptr0: ptr, ptr1: ptr, ptr2: ptr): void;
+        HingeConstraint_setLimit(p: ptr, low: number, upper: number, softness: number, biasFactor: number, relaxationFactor: number): void;
+        HingeConstraint_setAngularOnly(p: ptr, angular: number): void;
+        HingeConstraint_enableMotor(p: ptr, enable: boolean): void;
+        HingeConstraint_setMotorVelocity(p: ptr, velocity: number): void;
+        HingeConstraint_setMaxMotorImpulse(p: ptr, maxImpulse: number): void;
+        HingeConstraint_setMotorTarget(p: ptr, target: number, dt: number): void;
+        P2PConstraint_new(ptr0: ptr, ptr1: ptr, ptr2: ptr, ptr3: ptr): ptr;
+        P2PConstraint_setPivotA(ptr0: ptr, ptr1: ptr): void;
+        P2PConstraint_setPivotB(ptr0: ptr, ptr1: ptr): void;
+        TypedConstraint_setMaxImpulseThreshold(ptr0: ptr, maxImpulse: number): void;
+        FixedConstraint_new(ptr0: ptr, ptr1: ptr, ptr2: ptr, ptr3: ptr): ptr;
+        FixedConstraint_setFrames(ptr0: ptr, ptr1: ptr, ptr2: ptr): void;
+        Generic6DofSpring2Constraint_new(ptr0: ptr, ptr1: ptr, ptr2: ptr, ptr3: ptr, rotateOrder: number): ptr;
+        Generic6DofSpring2Constraint_setFrames(ptr0: ptr, ptr1: ptr, ptr2: ptr): void;
+        Generic6DofSpring2Constraint_setLimit(ptr0: ptr, index: number, lo: number, hi: number): void;
+        Generic6DofSpring2Constraint_enableSpring(ptr0: ptr, index: number, onOff: boolean): void;
+        Generic6DofSpring2Constraint_setStiffness(ptr0: ptr, index: number, stiffness: number): void;
+        Generic6DofSpring2Constraint_setDamping(ptr0: ptr, index: number, damping: number): void;
+        Generic6DofSpring2Constraint_setBounce(ptr0: ptr, index: number, bounce: number): void;
+        Generic6DofSpring2Constraint_setEquilibriumPoint(ptr0: ptr, index: number, val: number): void;
+        Generic6DofSpring2Constraint_enableMotor(ptr0: ptr, index: number, onOff: boolean): void;
+        Generic6DofSpring2Constraint_setMaxMotorForce(ptr0: ptr, index: number, force: number): void;
+        Generic6DofSpring2Constraint_setTargetVelocity(ptr0: ptr, index: number, velocity: number): void;
+        Generic6DofSpring2Constraint_setServo(ptr0: ptr, index: number, onOff: boolean): number;
+        Generic6DofSpring2Constraint_setServoTarget(ptr0: ptr, index: number, target: number): number;
+
+        // shapes
+
+        // CollisionShape_getUserIndex(p: ptr): number;
+        // CollisionShape_setUserIndex(p: ptr, i: number): void;
+        CollisionShape_isCompound(p: ptr): boolean;
+        CollisionShape_setLocalScaling(p: ptr, scale: ptr): void;
+        CollisionShape_calculateLocalInertia(p: ptr, mass: number, localInertia: ptr): void;
+        CollisionShape_getAabb(p: ptr, t: ptr, min: ptr, max: ptr): void;
+        CollisionShape_getLocalBoundingSphere(p: ptr): number;
+        CollisionShape_setMargin(p: ptr, margin: number): void;
+        CollisionShape_setMaterial(p: ptr, mat: ptr): void;
+        CollisionShape_setUserPointer(p: ptr, p0: ptr): void;
+
+        EmptyShape_static(): ptr;
+
+        ConvexInternalShape_getImplicitShapeDimensions(p: ptr): ptr;
+
+        BoxShape_new(p: ptr): ptr;
+        BoxShape_setUnscaledHalfExtents(p: ptr, halfExtents: ptr): void;
+
+        SphereShape_new(radius: number): ptr;
+        SphereShape_setUnscaledRadius(p: ptr, radius: number): void;
+
+        CylinderShape_new(halfExtents: ptr): ptr;
+        CylinderShape_updateProp(p: ptr, r: number, g: number, d: number): void;
+
+        CapsuleShape_new(radius: number, height: number): ptr;
+        CapsuleShape_updateProp(p: ptr, r: number, g: number, d: number): void;
+
+        ConeShape_new(radius: number, height: number): ptr;
+        ConeShape_setRadius(p: ptr, v: number): void;
+        ConeShape_setHeight(p: ptr, v: number): void;
+        ConeShape_setConeUpIndex(p: ptr, v: number): void;
+
+        StaticPlaneShape_new(normal: ptr, constant: number): ptr;
+        StaticPlaneShape_getPlaneNormal(p: ptr): ptr;
+        StaticPlaneShape_setPlaneConstant(p: ptr, constant: number): void;
+
+        TerrainShape_new(i: number, j: number, p: ptr, hs: number, min: number, max: number): ptr;
+
+        TriangleMesh_new(): ptr;
+        TriangleMesh_addTriangle(p: ptr, v0: ptr, v1: ptr, v2: ptr): void;
+        BvhTriangleMeshShape_new(p: ptr, c: boolean, bvh: boolean): ptr;
+        BvhTriangleMeshShape_getOptimizedBvh(p: ptr): ptr;
+        BvhTriangleMeshShape_setOptimizedBvh(p: ptr, p1: ptr, scaleX: number, scaleY: number, scaleZ: number);
+        ScaledBvhTriangleMeshShape_new(p: ptr, scaleX: number, scaleY: number, scaleZ: number): ptr;
+        ConvexTriangleMeshShape_new(p: ptr): ptr;
+
+        SimplexShape_new(): ptr;
+        SimplexShape_addVertex(p: ptr, pt: ptr): void;
+
+        ccCompoundShape_new(): ptr;
+        CompoundShape_getNumChildShapes(p: ptr): number;
+        CompoundShape_getChildShape(p: ptr, i: number): ptr;
+        CompoundShape_addChildShape(p: ptr, local: ptr, shape: ptr): void;
+        CompoundShape_removeChildShape(p: ptr, shape: ptr): void;
+        CompoundShape_updateChildTransform(p: ptr, i: number, trans: ptr, shouldRecalculateLocalAabb: boolean): void;
+        CompoundShape_setMaterial(p: ptr, i: number, f: number, r: number, rf: number, sf: number): void;
+
+        // collision
+
+        CollisionObject_new(): number;
+        CollisionObject_getCollisionShape(p: ptr): ptr;
+        CollisionObject_setContactProcessingThreshold(p: ptr, contactProcessingThreshold: number): void;
+        CollisionObject_getActivationState(p: ptr): number;
+        CollisionObject_setActivationState(p: ptr, newState: number): void;
+        CollisionObject_forceActivationState(p: ptr, newState: number): void;
+        CollisionObject_activate(p: ptr, forceActivation?: boolean): void;
+        CollisionObject_isActive(p: ptr): boolean;
+        CollisionObject_isKinematicObject(p: ptr): boolean;
+        CollisionObject_isStaticObject(p: ptr): boolean;
+        CollisionObject_isStaticOrKinematicObject(p: ptr): boolean;
+        CollisionObject_getWorldTransform(p: ptr): ptr;
+        CollisionObject_getCollisionFlags(p: ptr): number;
+        CollisionObject_setCollisionFlags(p: ptr, flags: number): void;
+        CollisionObject_setWorldTransform(p: ptr, transform: ptr): void;
+        CollisionObject_setCollisionShape(p: ptr, shape: ptr): void;
+        CollisionObject_setCcdMotionThreshold(p: ptr, ccdMotionThreshold: number): void;
+        CollisionObject_setCcdSweptSphereRadius(p: ptr, radius: number): void;
+        CollisionObject_getUserIndex(p: ptr): number;
+        CollisionObject_setUserIndex(p: ptr, index: number): void;
+        CollisionObject_getUserPointer(p: ptr): number;
+        CollisionObject_setUserPointer(p: ptr, userPointer: number): void;
+        CollisionObject_setMaterial(p: ptr, f: number, r: number, rf: number, sf: number): void;
+        CollisionObject_setIgnoreCollisionCheck(p: ptr, p0: ptr, v: boolean): void;
+
+        RigidBody_new(m: number, ms: number): ptr;
+        RigidBody_getFlags(p: ptr): number;
+        RigidBody_setFlags(p: ptr, flags: number): void;
+        RigidBody_setGravity(p: ptr, g: ptr): number;
+        RigidBody_setDamping(p: ptr, lin: number, ang: number): void;
+        RigidBody_setMass(p: ptr, m: number);
+        RigidBody_setMassProps(p: ptr, m: number, localInertia: ptr): void;
+        RigidBody_setLinearFactor(p: ptr, f: ptr): number;
+        RigidBody_setAngularFactor(p: ptr, f: ptr): number;
+        RigidBody_getLinearVelocity(p: ptr): ptr;
+        RigidBody_getAngularVelocity(p: ptr): ptr;
+        RigidBody_setLinearVelocity(p: ptr, v: ptr): void;
+        RigidBody_setAngularVelocity(p: ptr, v: ptr): void;
+        RigidBody_clearState(p: ptr): void;
+        RigidBody_clearForces(p: ptr): void;
+        RigidBody_wantsSleeping(p: ptr): boolean;
+        RigidBody_setSleepingThresholds(p: ptr, linear: number, angular: number): void;
+        RigidBody_getLinearSleepingThreshold(p: ptr): number;
+        RigidBody_getMotionState(p: ptr): ptr;
+        RigidBody_applyTorque(p: ptr, f: ptr): void;
+        RigidBody_applyForce(p: ptr, f: ptr, rp: ptr): void;
+        RigidBody_applyImpulse(p: ptr, f: ptr, rp: ptr): void;
+
+        // dynamic
+
+        DefaultCollisionConfiguration_static(): ptr;
+        CollisionDispatcher_new(): ptr;
+        Dispatcher_getNumManifolds(p: ptr): number;
+        Dispatcher_getManifoldByIndexInternal(p: ptr, i: number): ptr;
+
+        ManifoldPoint_getShape0(p: ptr): ptr;
+        ManifoldPoint_getShape1(p: ptr): ptr;
+        ManifoldPoint_get_m_index0(p: ptr): number;
+        ManifoldPoint_get_m_index1(p: ptr): number;
+        PersistentManifold_getBody0(p: ptr): ptr;
+        PersistentManifold_getBody1(p: ptr): ptr;
+        PersistentManifold_getNumContacts(p: ptr): number;
+        PersistentManifold_getContactPoint(p: ptr, i: number): ptr;
+        ManifoldPoint_get_m_localPointA(p: ptr): ptr;
+        ManifoldPoint_get_m_localPointB(p: ptr): ptr;
+        ManifoldPoint_get_m_positionWorldOnA(p: ptr): ptr;
+        ManifoldPoint_get_m_positionWorldOnB(p: ptr): ptr;
+        ManifoldPoint_get_m_normalWorldOnB(p: ptr): ptr;
+        ManifoldPoint_get_m_positionWorldOnB(p: ptr): ptr;
+
+        DbvtBroadphase_new(): ptr;
+        SequentialImpulseConstraintSolver_new(): ptr;
+
+        CollisionWorld_addCollisionObject(p: ptr, body: ptr, g: number, m: number): void;
+        CollisionWorld_removeCollisionObject(p: ptr, body: ptr): void;
+        CollisionWorld_rayTest(p: ptr, p0: ptr, p1: ptr, p2: ptr): void;
+        CollisionWorld_convexSweepTest(p: ptr, castShape: ptr, from: ptr, to: ptr, resultCallback: ptr, allowedCcdPenetration: ptr): void;
+
+        ccDiscreteDynamicsWorld_new(dispatcher: ptr, pairCache: ptr, solver: ptr): ptr;
+        ccDiscreteDynamicsWorld_setAllowSleep(p: ptr, v: boolean): void;
+        DynamicsWorld_setGravity(p: ptr, g: ptr): void;
+        DynamicsWorld_stepSimulation(p: ptr, timeStep: number, maxSubSteps: number, fixedTimeStep: number): ptr;
+        DynamicsWorld_addRigidBody(p: ptr, body: ptr, g: number, m: number): void;
+        DynamicsWorld_removeRigidBody(p: ptr, body: ptr): void;
+        DynamicsWorld_addConstraint(p: ptr, p2: ptr, v: boolean): void;
+        DynamicsWorld_removeConstraint(p: ptr, p2: ptr): void;
+        DynamicsWorld_addAction(p: ptr, action: ptr): void;
+        DynamicsWorld_removeAction(p: ptr, action: ptr): void;
+
+        RayCallback_hasHit(p: ptr): boolean;
+        ConvexCallback_hasHit(p: ptr): boolean;
+
+        ccAllRayCallback_static(): ptr;
+        ccAllRayCallback_setFlags(p: ptr, flag: number): void;
+        ccAllRayCallback_reset(p: ptr, p0: ptr, p1: ptr, m: number, q: boolean): void;
+        ccAllRayCallback_getHitPointWorld(p: ptr): ptr;
+        ccAllRayCallback_getHitNormalWorld(p: ptr): ptr;
+        ccAllRayCallback_getCollisionShapePtrs(p: ptr): ptr;
+
+        ccClosestRayCallback_static(): ptr;
+        ccClosestRayCallback_setFlags(p: ptr, flag: number): void;
+        ccClosestRayCallback_reset(p: ptr, p0: ptr, p1: ptr, m: number, q: boolean): void;
+        ccClosestRayCallback_getHitPointWorld(p: ptr): ptr;
+        ccClosestRayCallback_getHitNormalWorld(p: ptr): ptr;
+        ccClosestRayCallback_getCollisionShapePtr(p: ptr): ptr;
+
+        ccAllConvexCallback_static(): ptr;
+        ccAllConvexCallback_reset(p: ptr, p0: ptr, p1: ptr, m: number, q: boolean): void;
+        ccAllConvexCallback_getHitPointWorld(p: ptr): ptr;
+        ccAllConvexCallback_getHitNormalWorld(p: ptr): ptr;
+        ccAllConvexCallback_getCollisionShapePtrs(p: ptr): ptr;
+
+        ccClosestConvexCallback_static(): ptr;
+        ccClosestConvexCallback_reset(p: ptr, p0: ptr, p1: ptr, m: number, q: boolean): void;
+        ccClosestConvexCallback_getHitPointWorld(p: ptr): ptr;
+        ccClosestConvexCallback_getHitNormalWorld(p: ptr): ptr;
+        ccClosestConvexCallback_getCollisionShapePtr(p: ptr): ptr;
+
+        ccMaterial_new(): ptr;
+        ccMaterial_set(p: ptr, r: number, f: number, rf: number, sf: number): void;
+
+        // CharacterController
+        ControllerHitReport_new(): ptr;
+        CharacterController_getGhostObject(ptrCCT: ptr): ptr;
+        ControllerHit_getCurrentController(p: ptr): ptr;
+        ControllerHit_getHitWorldPos(p: ptr): ptr;
+        ControllerHit_getHitWorldNormal(p: ptr): ptr;
+        ControllerHit_getHitMotionDir(p: ptr): ptr;         //CCT hit Motion direction
+        ControllerHit_getHitMotionLength(p: ptr): number;   //CCT hit Motion length
+        ControllerShapeHit_getHitShape(p: ptr): ptr;
+        ControllerShapeHit_getHitCollisionObject(p: ptr): ptr;
+        CharacterController_move(ptrCCT: ptr, ptrMovement: ptr, minDist: number, deltaTime: number):number;
+        CharacterController_getPosition(ptrCCT: ptr);
+        CharacterController_setContactOffset(ptrCCT: ptr, v: number);
+        CharacterController_setStepOffset(ptrCCT: ptr, v: number);
+        CharacterController_setSlopeLimit(ptrCCT: ptr, v: number);
+        CharacterController_setCollision(ptrCCT: ptr, collision: boolean);
+        CharacterController_setOverlapRecovery(ptrCCT: ptr, value: boolean);
+        CapsuleCharacterControllerDesc_new(maxSlopeRadians: number, stepHeight: number, contactOffset: number, 
+            ptrUpAxis: ptr, ptrInitPos: ptr, ptruUserControllerHitReport: ptr, radius: number, height: number): ptr;
+        CapsuleCharacterController_new(collisionWorld: ptr, ptrBtCapsuleCharacterControllerDesc: ptr, userObjectPointer: ptr): ptr;
+        CapsuleCharacterController_setRadius(ptrCCT: ptr, radius: number): void;
+        CapsuleCharacterController_setHeight(ptrCCT: ptr, height: number): void;
+        BoxCharacterControllerDesc_new(maxSlopeRadians: number, stepHeight: number, contactOffset: number, 
+            ptrUpAxis: ptr, ptrInitPos: ptr, ptruUserControllerHitReport: ptr, halfHeight: number, halfSideExtent: number, halfForwardExtent: number): ptr;
+        BoxCharacterController_new(collisionWorld: ptr, ptrBtBoxCharacterControllerDesc: ptr, userObjectPointer: ptr): ptr;
+        BoxCharacterController_setHalfHeight(ptrCCT: ptr, v: number): void;
+        BoxCharacterController_setHalfSideExtent(ptrCCT: ptr, v: number): void;
+        BoxCharacterController_setHalfForwardExtent(ptrCCT: ptr, v: number): void;
+    }
+}

emscripten/external-wasm.d.ts

@@ -0,0 +1,7 @@
+declare module 'external:emscripten/*.wasm' {
+    /**
+     * This is a url relative from build output chunk.
+     */
+    const wasmPath: string;
+    export default wasmPath;
+}

emscripten/physx/physx.d.ts

@@ -0,0 +1,103 @@
+/// <reference path="./phy.d.ts" />
+
+declare module 'external:emscripten/physx/physx.release.asm.js' {
+  export default PhysX;
+}
+
+declare module 'external:emscripten/physx/physx.release.wasm.js' {
+  export default PhysX;
+}
+
+// tslint:disable
+declare function PhysX (moduleOptions?: any): Promise<void>;
+
+declare namespace PhysX {
+  type Constructor<T = {}> = new (...args: any[]) => T;
+  type VoidPtr = number;
+  const NULL: {};
+  const HEAPF32: Float32Array;
+  function destroy (obj: PhysX.Type): void;
+  function castObject<T1, T2 extends PhysX.Type> (obj: T1, fun: Constructor<T2>): T2;
+  function wrapPointer<T extends PhysX.Type> (params: number, obj: Constructor<T>): T;
+  function addFunction (params: Function): number;
+  function getClass (obj: PhysX.Type): void;
+  function getPointer (obj: PhysX.Type): void;
+  function getCache (fun: Constructor<PhysX.Type>): void;
+  function _malloc (byte: number): number;
+  function _free (...args: any): any;
+  function compare (obj1: PhysX.Type, obj2: PhysX.Type): boolean;
+
+  class GeometryType {
+    Enum: {
+      eSPHERE: number,
+      ePLANE: number,
+      eCAPSULE: number,
+      eBOX: number,
+      eCONVEXMESH: number,
+      eTRIANGLEMESH: number,
+      eHEIGHTFIELD: number,
+      eGEOMETRY_COUNT: number,	//!< internal use only!
+      eINVALID: number //= -1		//!< internal use only!
+    }
+  }
+
+  const PX_PHYSICS_VERSION: number
+  interface AllocatorCallback { }
+  class DefaultErrorCallback implements AllocatorCallback { }
+  interface ErrorCallback { }
+  class DefaultAllocator implements ErrorCallback { }
+
+  class Foundation { }
+  function createFoundation (a: number, b: AllocatorCallback, c: ErrorCallback): Foundation
+
+  class Transform {
+    constructor (p: number[], q: number[]);
+    setPosition (t: number[]): void;
+    getPosition (): number[];
+    setQuaternion (t: number[]): void;
+    getQuaternion (): number[];
+  }
+
+  class Base { }
+
+  class Geometry { getType (): number }
+  class BoxGeometry extends Geometry { constructor (x: number, y: number, z: number); }
+  class SphereGeometry extends Geometry { constructor (r: number); }
+
+  class Material extends Base { }
+
+  class Shape extends Base { }
+
+  class Actor extends Base {
+    getGlobalPose (): Transform;
+  }
+  class RigidActor extends Actor {
+    attachShape (shape: Shape): void;
+    detachShape (shape: Shape, wakeOnLostTouch?: boolean | true): void;
+  }
+  class RigidBody extends RigidActor { }
+  class RigidStatic extends RigidBody { }
+  class RigidDynamic extends RigidBody { }
+
+  class SceneDesc { }
+  class Scene {
+    simulate (timeStep: number): void;
+    fetchResults (b: boolean): void;
+    getActiveActors (len: number): Actor[];
+  }
+
+  class Physics {
+    createSceneDesc (): SceneDesc;
+    createScene (a: SceneDesc): Scene;
+    createRigidDynamic (a: Transform): RigidDynamic;
+    createRigidStatic (a: Transform): RigidStatic;
+    createMaterial (staticFriction: number, dynamicFriction: number, restitution: number): Material;
+    //shapeFlags = PxShapeFlag:: eVISUALIZATION | PxShapeFlag:: eSCENE_QUERY_SHAPE | PxShapeFlag:: eSIMULATION_SHAPE
+    createShape (geometry: Geometry, material: Material, isExclusive: boolean | false, shapeFlags: number): Shape;
+  }
+  class TolerancesScale { length: number | 1.0; speed: number | 10.0 }
+  class Pvd { }
+  function createPhysics (a?: number, b?: Foundation, c?: TolerancesScale, trackOutstandingAllocations?: boolean, e?: Pvd): Physics;
+
+  type Type = {}
+}

emscripten/spine/spine.d.ts

@@ -0,0 +1,46 @@
+declare module 'external:emscripten/spine/spine.asm.js' {
+    export default SpineWasm;
+}
+
+declare function SpineWasm (moduleOptions?: any): Promise<void>;
+
+declare namespace SpineWasm {
+    type ptr = number;
+    interface instance {
+        spineWasmInstanceInit(): number;
+        spineWasmInstanceDestroy(): number;
+        queryStoreMemory(): ptr;
+        createSkeletonObject (): ptr;
+        setSkeletonData(objPtr: ptr, datPtr: ptr);
+        setAnimation(objPtr: ptr, length: number, trackIndex: number, loop: boolean): boolean;
+        clearTrack(objPtr: ptr, trackIndex: number): void;
+        clearTracks(objPtr: ptr): void;
+        setToSetupPose(objPtr: ptr): void;
+        setSlotsToSetupPose(objPtr: ptr): void;
+        setBonesToSetupPose(objPtr: ptr): void;
+        setTimeScale(objPtr: ptr, timeScale: number): number;
+        setSkin(objPtr: ptr, length: number): number;
+        updateAnimation(objPtr: ptr, dltTime: number): number;
+        setMix(objPtr: ptr, start: number, fromLength: number, toLength: number, duration: number);
+        setAttachment(objPtr: ptr, start: number, length1: number, length2: number);
+        updateRenderData(objPtr: ptr): number;
+        getDrawOrderSize(objPtr: ptr): number;
+        getSlotNameByOrder(objPtr: ptr, index: number): number;
+        getBoneMatrix(objPtr: ptr, index: number): number;
+        queryMemory(size: number): number;
+        freeMemory(data: ptr);
+        setDefaultScale(objPtr: ptr, scale: number): boolean;
+        setVertexEffect(objPtr: ptr, effect: number, effectType: number);
+        setPremultipliedAlpha(objPtr: ptr, premultipliedAlpha: boolean);
+        setColor(objPtr: ptr, r: number, g: number, b: number, a: number);
+        destroyInstance(objPtr: ptr);
+        retainSkeletonDataByUUID(length: number): number;
+        initSkeletonData(length: number, isJosn: boolean): number;
+        recordSkeletonDataUUID(length: number, datPtr: number);
+        createJitterVertexEffect(x: number, y: number): number;
+        updateJitterParameters(handle: number, x: number, y: number);
+        createSwirlVertexEffect(radius: number, power: number, usePowerOut: boolean): number;
+        updateSwirlParameters(handle: number, centerX: number, centerY: number, radius: number, angle: number);
+        memory: any;
+    }
+}

emscripten/webgpu/webgpu.d.ts

@@ -0,0 +1,9 @@
+declare module 'external:emscripten/webgpu/webgpu_wasm.js' {
+    function factory (gfx: any): Promise<any>;
+    export default factory;
+}
+
+declare module 'external:emscripten/webgpu/glslang.js' {
+    function factory (wasmUrl: string): Promise<any>;
+    export default factory;
+}

ios/CMakeLists.txt

@@ -206,17 +206,6 @@ else()
   set(PhysXSDK)
 endif()
 
-if(USE_AR_MODULE)
-  set(ARSDK libAR)
-  add_library(libAR STATIC IMPORTED GLOBAL)
-  set_target_properties(libAR PROPERTIES
-    IMPORTED_LOCATION ${CMAKE_CURRENT_LIST_DIR}/libs/ar/libar.a
-    INTERFACE_INCLUDE_DIRECTORIES ${CMAKE_CURRENT_LIST_DIR}/../../cocos/xr
-  )
-else()
-  set(ARSDK)
-endif()
-
 list(APPEND CC_EXTERNAL_INCLUDES
     ${CMAKE_CURRENT_LIST_DIR}/include
 )
@@ -235,7 +224,6 @@ list(APPEND CC_EXTERNAL_LIBS
     ${spirv-cross_libs_name}
     ${tbb_libs_name}
     ${PhysXSDK}
-    ${ARSDK}
 )
 
 set(ZLIB z)

sources/CMakeLists.txt

@@ -57,6 +57,7 @@ endif()
 if(ANDROID)
     set(CC_GAME_ACTIVITY_SOURCES
         ${CMAKE_CURRENT_LIST_DIR}/android-gamesdk/GameActivity/game-activity/include/game-activity/GameActivity.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/android-gamesdk/GameActivity/game-activity/include/game-activity/system_utils.cpp
         ${CMAKE_CURRENT_LIST_DIR}/android-gamesdk/GameActivity/game-activity/include/game-activity/native_app_glue/android_native_app_glue.c
         ${CMAKE_CURRENT_LIST_DIR}/android-gamesdk/GameActivity/game-activity/include/game-text-input/gametextinput.cpp
     )

sources/android-gamesdk/GameActivity/game-activity/include/game-activity/GameActivity.cpp

@@ -16,6 +16,7 @@
 #define LOG_TAG "GameActivity"
 
 #include "GameActivity.h"
+#include "system_utils.h"
 
 #include <android/api-level.h>
 #include <android/asset_manager.h>
@@ -870,138 +871,119 @@ static struct {
     jmethodID getClassification;
     jmethodID getEdgeFlags;
 
+    jmethodID getHistorySize;
+    jmethodID getHistoricalEventTime;
+
     jmethodID getPointerCount;
     jmethodID getPointerId;
+
+    jmethodID getToolType;
+
     jmethodID getRawX;
     jmethodID getRawY;
     jmethodID getXPrecision;
     jmethodID getYPrecision;
     jmethodID getAxisValue;
+
+    jmethodID getHistoricalAxisValue;
 } gMotionEventClassInfo;
 
+extern "C" void GameActivityMotionEvent_destroy(
+    GameActivityMotionEvent *c_event) {
+    delete c_event->historicalAxisValues;
+    delete c_event->historicalEventTimesMillis;
+    delete c_event->historicalEventTimesNanos;
+}
+
 extern "C" void GameActivityMotionEvent_fromJava(
-    JNIEnv *env, jobject motionEvent, GameActivityMotionEvent *out_event) {
-    static bool gMotionEventClassInfoInitialized = false;
-    if (!gMotionEventClassInfoInitialized) {
-        int sdkVersion = GetSystemPropAsInt("ro.build.version.sdk");
-        gMotionEventClassInfo = {0};
-        jclass motionEventClass = env->FindClass("android/view/MotionEvent");
-        gMotionEventClassInfo.getDeviceId =
-            env->GetMethodID(motionEventClass, "getDeviceId", "()I");
-        gMotionEventClassInfo.getSource =
-            env->GetMethodID(motionEventClass, "getSource", "()I");
-        gMotionEventClassInfo.getAction =
-            env->GetMethodID(motionEventClass, "getAction", "()I");
-        gMotionEventClassInfo.getEventTime =
-            env->GetMethodID(motionEventClass, "getEventTime", "()J");
-        gMotionEventClassInfo.getDownTime =
-            env->GetMethodID(motionEventClass, "getDownTime", "()J");
-        gMotionEventClassInfo.getFlags =
-            env->GetMethodID(motionEventClass, "getFlags", "()I");
-        gMotionEventClassInfo.getMetaState =
-            env->GetMethodID(motionEventClass, "getMetaState", "()I");
-        if (sdkVersion >= 23) {
-            gMotionEventClassInfo.getActionButton =
-                env->GetMethodID(motionEventClass, "getActionButton", "()I");
-        }
-        if (sdkVersion >= 14) {
-            gMotionEventClassInfo.getButtonState =
-                env->GetMethodID(motionEventClass, "getButtonState", "()I");
-        }
-        if (sdkVersion >= 29) {
-            gMotionEventClassInfo.getClassification =
-                env->GetMethodID(motionEventClass, "getClassification", "()I");
-        }
-        gMotionEventClassInfo.getEdgeFlags =
-            env->GetMethodID(motionEventClass, "getEdgeFlags", "()I");
-        gMotionEventClassInfo.getPointerCount =
-            env->GetMethodID(motionEventClass, "getPointerCount", "()I");
-        gMotionEventClassInfo.getPointerId =
-            env->GetMethodID(motionEventClass, "getPointerId", "(I)I");
-        if (sdkVersion >= 29) {
-            gMotionEventClassInfo.getRawX =
-                env->GetMethodID(motionEventClass, "getRawX", "(I)F");
-            gMotionEventClassInfo.getRawY =
-                env->GetMethodID(motionEventClass, "getRawY", "(I)F");
-        }
-        gMotionEventClassInfo.getXPrecision =
-            env->GetMethodID(motionEventClass, "getXPrecision", "()F");
-        gMotionEventClassInfo.getYPrecision =
-            env->GetMethodID(motionEventClass, "getYPrecision", "()F");
-        gMotionEventClassInfo.getAxisValue =
-            env->GetMethodID(motionEventClass, "getAxisValue", "(II)F");
-
-        gMotionEventClassInfoInitialized = true;
-    }
-
-    int pointerCount =
-        env->CallIntMethod(motionEvent, gMotionEventClassInfo.getPointerCount);
+    JNIEnv *env, jobject motionEvent, GameActivityMotionEvent *out_event,
+    int pointerCount, int historySize, int deviceId, int source, int action,
+    int64_t eventTime, int64_t downTime, int flags, int metaState,
+    int actionButton, int buttonState, int classification, int edgeFlags,
+    float precisionX, float precisionY) {
     pointerCount =
-        std::min(pointerCount, GAMEACTIVITY_MAX_NUM_POINTERS_IN_MOTION_EVENT);
+            std::min(pointerCount, GAMEACTIVITY_MAX_NUM_POINTERS_IN_MOTION_EVENT);
     out_event->pointerCount = pointerCount;
-    for (int i = 0; i < pointerCount; ++i) {
+    for (jint i = 0; i < pointerCount; ++i) {
         out_event->pointers[i] = {
-            /*id=*/env->CallIntMethod(motionEvent,
-                                      gMotionEventClassInfo.getPointerId, i),
-            /*axisValues=*/{0},
-            /*rawX=*/gMotionEventClassInfo.getRawX
-                ? env->CallFloatMethod(motionEvent,
-                                       gMotionEventClassInfo.getRawX, i)
-                : 0,
-            /*rawY=*/gMotionEventClassInfo.getRawY
-                ? env->CallFloatMethod(motionEvent,
-                                       gMotionEventClassInfo.getRawY, i)
-                : 0,
+                /*id=*/env->CallIntMethod(motionEvent,
+                                          gMotionEventClassInfo.getPointerId, i),
+                /*toolType=*/
+                       env->CallIntMethod(motionEvent, gMotionEventClassInfo.getToolType,
+                                          i),
+                /*axisValues=*/{0.0F},
+                /*rawX=*/gMotionEventClassInfo.getRawX
+                         ? env->CallFloatMethod(motionEvent,
+                                                gMotionEventClassInfo.getRawX, i)
+                         : 0.0F,
+                /*rawY=*/gMotionEventClassInfo.getRawY
+                         ? env->CallFloatMethod(motionEvent,
+                                                gMotionEventClassInfo.getRawY, i)
+                         : 0.0F,
         };
 
         for (int axisIndex = 0;
              axisIndex < GAME_ACTIVITY_POINTER_INFO_AXIS_COUNT; ++axisIndex) {
             if (enabledAxes[axisIndex]) {
                 out_event->pointers[i].axisValues[axisIndex] =
-                    env->CallFloatMethod(motionEvent,
-                                         gMotionEventClassInfo.getAxisValue,
-                                         axisIndex, i);
+                        env->CallFloatMethod(motionEvent,
+                                             gMotionEventClassInfo.getAxisValue,
+                                             axisIndex, i);
             }
         }
     }
 
-    out_event->deviceId =
-        env->CallIntMethod(motionEvent, gMotionEventClassInfo.getDeviceId);
-    out_event->source =
-        env->CallIntMethod(motionEvent, gMotionEventClassInfo.getSource);
-    out_event->action =
-        env->CallIntMethod(motionEvent, gMotionEventClassInfo.getAction);
-    out_event->eventTime =
-        env->CallLongMethod(motionEvent, gMotionEventClassInfo.getEventTime) *
-        1000000;
-    out_event->downTime =
-        env->CallLongMethod(motionEvent, gMotionEventClassInfo.getDownTime) *
-        1000000;
-    out_event->flags =
-        env->CallIntMethod(motionEvent, gMotionEventClassInfo.getFlags);
-    out_event->metaState =
-        env->CallIntMethod(motionEvent, gMotionEventClassInfo.getMetaState);
-    out_event->actionButton =
-        gMotionEventClassInfo.getActionButton
-            ? env->CallIntMethod(motionEvent,
-                                 gMotionEventClassInfo.getActionButton)
-            : 0;
-    out_event->buttonState =
-        gMotionEventClassInfo.getButtonState
-            ? env->CallIntMethod(motionEvent,
-                                 gMotionEventClassInfo.getButtonState)
-            : 0;
-    out_event->classification =
-        gMotionEventClassInfo.getClassification
-            ? env->CallIntMethod(motionEvent,
-                                 gMotionEventClassInfo.getClassification)
-            : 0;
-    out_event->edgeFlags =
-        env->CallIntMethod(motionEvent, gMotionEventClassInfo.getEdgeFlags);
-    out_event->precisionX =
-        env->CallFloatMethod(motionEvent, gMotionEventClassInfo.getXPrecision);
-    out_event->precisionY =
-        env->CallFloatMethod(motionEvent, gMotionEventClassInfo.getYPrecision);
+    out_event->historySize = historySize;
+    out_event->historicalAxisValues =
+            new float[historySize * pointerCount *
+                      GAME_ACTIVITY_POINTER_INFO_AXIS_COUNT];
+    out_event->historicalEventTimesMillis = new long[historySize];
+    out_event->historicalEventTimesNanos = new long[historySize];
+
+    for (int historyIndex = 0; historyIndex < historySize; historyIndex++) {
+        out_event->historicalEventTimesMillis[historyIndex] =
+                env->CallLongMethod(motionEvent,
+                                    gMotionEventClassInfo.getHistoricalEventTime,
+                                    historyIndex);
+        out_event->historicalEventTimesNanos[historyIndex] =
+                out_event->historicalEventTimesMillis[historyIndex] * 1000000;
+        for (int i = 0; i < pointerCount; ++i) {
+            int pointerOffset = i * GAME_ACTIVITY_POINTER_INFO_AXIS_COUNT;
+            int historyAxisOffset = historyIndex * pointerCount *
+                                    GAME_ACTIVITY_POINTER_INFO_AXIS_COUNT;
+            float *axisValues =
+                    &out_event
+                            ->historicalAxisValues[historyAxisOffset + pointerOffset];
+            for (int axisIndex = 0;
+                 axisIndex < GAME_ACTIVITY_POINTER_INFO_AXIS_COUNT;
+                 ++axisIndex) {
+                if (enabledAxes[axisIndex]) {
+                    axisValues[axisIndex] = env->CallFloatMethod(
+                            motionEvent,
+                            gMotionEventClassInfo.getHistoricalAxisValue, axisIndex,
+                            i, historyIndex);
+                }
+            }
+        }
+    }
+
+    out_event->deviceId = deviceId;
+    out_event->source = source;
+    out_event->action = action;
+
+    out_event->eventTime = eventTime;
+    out_event->downTime = downTime;
+
+    out_event->flags = flags;
+    out_event->metaState = metaState;
+
+    out_event->actionButton = actionButton;
+    out_event->buttonState = buttonState;
+    out_event->classification = classification;
+    out_event->edgeFlags = edgeFlags;
+
+    out_event->precisionX = precisionX;
+    out_event->precisionY = precisionY;
 }
 
 static struct {
@@ -1018,6 +1000,8 @@ static struct {
     jmethodID getModifiers;
     jmethodID getRepeatCount;
     jmethodID getKeyCode;
+    jmethodID getScanCode;
+    jmethodID getUnicodeChar;
 } gKeyEventClassInfo;
 
 extern "C" void GameActivityKeyEvent_fromJava(JNIEnv *env, jobject keyEvent,
@@ -1077,14 +1061,25 @@ extern "C" void GameActivityKeyEvent_fromJava(JNIEnv *env, jobject keyEvent,
 }
 
 static bool onTouchEvent_native(JNIEnv *env, jobject javaGameActivity,
-                                jlong handle, jobject motionEvent) {
+                                jlong handle, jobject motionEvent,
+                                int pointerCount, int historySize, int deviceId,
+                                int source, int action, int64_t eventTime,
+                                int64_t downTime, int flags, int metaState,
+                                int actionButton, int buttonState,
+                                int classification, int edgeFlags,
+                                float precisionX, float precisionY) {
     if (handle == 0) return false;
     NativeCode *code = (NativeCode *)handle;
     if (code->callbacks.onTouchEvent == nullptr) return false;
 
     static GameActivityMotionEvent c_event;
-    GameActivityMotionEvent_fromJava(env, motionEvent, &c_event);
-    return code->callbacks.onTouchEvent(code, &c_event);
+    GameActivityMotionEvent_fromJava(
+        env, motionEvent, &c_event, pointerCount, historySize, deviceId, source,
+        action, eventTime, downTime, flags, metaState, actionButton,
+        buttonState, classification, edgeFlags, precisionX, precisionY);
+    auto result = code->callbacks.onTouchEvent(code, &c_event);
+    GameActivityMotionEvent_destroy(&c_event);
+    return result;
 }
 
 static bool onKeyUp_native(JNIEnv *env, jobject javaGameActivity, jlong handle,
@@ -1184,7 +1179,7 @@ static const JNINativeMethod g_methods[] = {
     {"onSurfaceRedrawNeededNative", "(JLandroid/view/Surface;)V",
      (void *)onSurfaceRedrawNeeded_native},
     {"onSurfaceDestroyedNative", "(J)V", (void *)onSurfaceDestroyed_native},
-    {"onTouchEventNative", "(JLandroid/view/MotionEvent;)Z",
+    {"onTouchEventNative", "(JLandroid/view/MotionEvent;IIIIIJJIIIIIIFF)Z",
      (void *)onTouchEvent_native},
     {"onKeyDownNative", "(JLandroid/view/KeyEvent;)Z",
      (void *)onKeyDown_native},
@@ -1247,6 +1242,104 @@ static int jniRegisterNativeMethods(JNIEnv *env, const char *className,
     LOG_FATAL("RegisterNatives failed for '%s'; aborting...", className);
 }
 
+static void initKeyEvents(JNIEnv *env) {
+    int sdkVersion = gamesdk::GetSystemPropAsInt("ro.build.version.sdk");
+    gKeyEventClassInfo = {0};
+    jclass keyEventClass = env->FindClass("android/view/KeyEvent");
+    gKeyEventClassInfo.getDeviceId =
+        env->GetMethodID(keyEventClass, "getDeviceId", "()I");
+    gKeyEventClassInfo.getSource =
+        env->GetMethodID(keyEventClass, "getSource", "()I");
+    gKeyEventClassInfo.getAction =
+        env->GetMethodID(keyEventClass, "getAction", "()I");
+    gKeyEventClassInfo.getEventTime =
+        env->GetMethodID(keyEventClass, "getEventTime", "()J");
+    gKeyEventClassInfo.getDownTime =
+        env->GetMethodID(keyEventClass, "getDownTime", "()J");
+    gKeyEventClassInfo.getFlags =
+        env->GetMethodID(keyEventClass, "getFlags", "()I");
+    gKeyEventClassInfo.getMetaState =
+        env->GetMethodID(keyEventClass, "getMetaState", "()I");
+    if (sdkVersion >= 13) {
+        gKeyEventClassInfo.getModifiers =
+            env->GetMethodID(keyEventClass, "getModifiers", "()I");
+    }
+    gKeyEventClassInfo.getRepeatCount =
+        env->GetMethodID(keyEventClass, "getRepeatCount", "()I");
+    gKeyEventClassInfo.getKeyCode =
+        env->GetMethodID(keyEventClass, "getKeyCode", "()I");
+    gKeyEventClassInfo.getScanCode =
+        env->GetMethodID(keyEventClass, "getScanCode", "()I");
+    gKeyEventClassInfo.getUnicodeChar =
+        env->GetMethodID(keyEventClass, "getUnicodeChar", "()I");
+}
+
+static void initMotionEvents(JNIEnv *env) {
+    int sdkVersion = gamesdk::GetSystemPropAsInt("ro.build.version.sdk");
+    gMotionEventClassInfo = {0};
+    jclass motionEventClass = env->FindClass("android/view/MotionEvent");
+    gMotionEventClassInfo.getDeviceId =
+        env->GetMethodID(motionEventClass, "getDeviceId", "()I");
+    gMotionEventClassInfo.getSource =
+        env->GetMethodID(motionEventClass, "getSource", "()I");
+    gMotionEventClassInfo.getAction =
+        env->GetMethodID(motionEventClass, "getAction", "()I");
+    gMotionEventClassInfo.getEventTime =
+        env->GetMethodID(motionEventClass, "getEventTime", "()J");
+    gMotionEventClassInfo.getDownTime =
+        env->GetMethodID(motionEventClass, "getDownTime", "()J");
+    gMotionEventClassInfo.getFlags =
+        env->GetMethodID(motionEventClass, "getFlags", "()I");
+    gMotionEventClassInfo.getMetaState =
+        env->GetMethodID(motionEventClass, "getMetaState", "()I");
+    if (sdkVersion >= 23) {
+        gMotionEventClassInfo.getActionButton =
+            env->GetMethodID(motionEventClass, "getActionButton", "()I");
+    }
+    if (sdkVersion >= 14) {
+        gMotionEventClassInfo.getButtonState =
+            env->GetMethodID(motionEventClass, "getButtonState", "()I");
+    }
+    if (sdkVersion >= 29) {
+        gMotionEventClassInfo.getClassification =
+            env->GetMethodID(motionEventClass, "getClassification", "()I");
+    }
+    gMotionEventClassInfo.getEdgeFlags =
+        env->GetMethodID(motionEventClass, "getEdgeFlags", "()I");
+
+    gMotionEventClassInfo.getHistorySize =
+        env->GetMethodID(motionEventClass, "getHistorySize", "()I");
+    gMotionEventClassInfo.getHistoricalEventTime =
+        env->GetMethodID(motionEventClass, "getHistoricalEventTime", "(I)J");
+
+    gMotionEventClassInfo.getPointerCount =
+        env->GetMethodID(motionEventClass, "getPointerCount", "()I");
+    gMotionEventClassInfo.getPointerId =
+        env->GetMethodID(motionEventClass, "getPointerId", "(I)I");
+    gMotionEventClassInfo.getToolType =
+        env->GetMethodID(motionEventClass, "getToolType", "(I)I");
+    if (sdkVersion >= 29) {
+        gMotionEventClassInfo.getRawX =
+            env->GetMethodID(motionEventClass, "getRawX", "(I)F");
+        gMotionEventClassInfo.getRawY =
+            env->GetMethodID(motionEventClass, "getRawY", "(I)F");
+    }
+    gMotionEventClassInfo.getXPrecision =
+        env->GetMethodID(motionEventClass, "getXPrecision", "()F");
+    gMotionEventClassInfo.getYPrecision =
+        env->GetMethodID(motionEventClass, "getYPrecision", "()F");
+    gMotionEventClassInfo.getAxisValue =
+        env->GetMethodID(motionEventClass, "getAxisValue", "(II)F");
+
+    gMotionEventClassInfo.getHistoricalAxisValue =
+        env->GetMethodID(motionEventClass, "getHistoricalAxisValue", "(III)F");
+}
+
+static void GameActivityEventsInit(JNIEnv *env) {
+    initMotionEvents(env);
+    initKeyEvents(env);
+}
+
 extern "C" int GameActivity_register(JNIEnv *env) {
     ALOGD("GameActivity_register");
     jclass activity_class;
@@ -1289,6 +1382,9 @@ extern "C" int GameActivity_register(JNIEnv *env) {
                              windowInsetsCompatType_class, methodNames[i],
                              "()I");
     }*/
+
+    GameActivityEventsInit(env);
+
     return jniRegisterNativeMethods(env, kGameActivityPathName, g_methods,
                                     NELEM(g_methods));
 }

sources/android-gamesdk/GameActivity/game-activity/include/game-activity/GameActivity.h

@@ -137,6 +137,7 @@ typedef struct GameActivity {
  */
 typedef struct GameActivityPointerAxes {
     int32_t id;
+    int32_t toolType;
     float axisValues[GAME_ACTIVITY_POINTER_INFO_AXIS_COUNT];
     float rawX;
     float rawY;
@@ -240,6 +241,12 @@ typedef struct GameActivityMotionEvent {
 
     float precisionX;
     float precisionY;
+
+    int historySize;
+    long* historicalEventTimesMillis;
+    long* historicalEventTimesNanos;
+    float* historicalAxisValues;
+
 } GameActivityMotionEvent;
 
 /**
@@ -421,8 +428,12 @@ typedef struct GameActivityCallbacks {
  * activity.
  * Ownership of out_event is maintained by the caller.
  */
-void GameActivityMotionEvent_fromJava(JNIEnv* env, jobject motionEvent,
-                                      GameActivityMotionEvent* out_event);
+void GameActivityMotionEvent_fromJava(
+    JNIEnv *env, jobject motionEvent, GameActivityMotionEvent *out_event,
+    int pointerCount, int historySize, int deviceId, int source, int action,
+    int64_t eventTime, int64_t downTime, int flags, int metaState,
+    int actionButton, int buttonState, int classification, int edgeFlags,
+    float precisionX, float precisionY);
 
 /**
  * \brief Convert a Java `KeyEvent` to a `GameActivityKeyEvent`.

sources/android-gamesdk/GameActivity/game-activity/include/game-activity/system_utils.cpp

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "system_utils.h"
+
+#include <android/api-level.h>
+#include <stdlib.h>
+#include <sys/system_properties.h>
+
+namespace gamesdk {
+
+#if __ANDROID_API__ >= 26
+std::string getSystemPropViaCallback(const char* key,
+                                     const char* default_value = "") {
+    const prop_info* prop = __system_property_find(key);
+    if (prop == nullptr) {
+        return default_value;
+    }
+    std::string return_value;
+    auto thunk = [](void* cookie, const char* /*name*/, const char* value,
+                    uint32_t /*serial*/) {
+        if (value != nullptr) {
+            std::string* r = static_cast<std::string*>(cookie);
+            *r = value;
+        }
+    };
+    __system_property_read_callback(prop, thunk, &return_value);
+    return return_value;
+}
+#else
+std::string getSystemPropViaGet(const char* key,
+                                const char* default_value = "") {
+    char buffer[PROP_VALUE_MAX + 1] = "";  // +1 for terminator
+    int bufferLen = __system_property_get(key, buffer);
+    if (bufferLen > 0)
+        return buffer;
+    else
+        return "";
+}
+#endif
+
+std::string GetSystemProp(const char* key, const char* default_value) {
+#if __ANDROID_API__ >= 26
+    return getSystemPropViaCallback(key, default_value);
+#else
+    return getSystemPropViaGet(key, default_value);
+#endif
+}
+
+int GetSystemPropAsInt(const char* key, int default_value) {
+    std::string prop = GetSystemProp(key);
+    return prop == "" ? default_value : strtoll(prop.c_str(), nullptr, 10);
+}
+
+bool GetSystemPropAsBool(const char* key, bool default_value) {
+    return GetSystemPropAsInt(key, default_value) != 0;
+}
+
+}  // namespace gamesdk

sources/android-gamesdk/GameActivity/game-activity/include/game-activity/system_utils.h

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "string"
+
+namespace gamesdk {
+
+// Get the value of the given system property
+std::string GetSystemProp(const char* key, const char* default_value = "");
+
+// Get the value of the given system property as an integer
+int GetSystemPropAsInt(const char* key, int default_value = 0);
+
+// Get the value of the given system property as a bool
+bool GetSystemPropAsBool(const char* key, bool default_value = false);
+
+}  // namespace gamesdk

sources/android-gamesdk/GameController/GameControllerGameActivityMirror.h

@@ -33,6 +33,7 @@ namespace paddleboat {
 
 typedef struct Paddleboat_GameActivityPointerInfo {
     int32_t id;
+    int32_t toolType; // added in newer version
     float axisValues[PADDLEBOAT_GAME_ACTIVITY_POINTER_INFO_AXIS_COUNT];
     float rawX;
     float rawY;

versions.txt

@@ -139,7 +139,7 @@ glslang (Built using https://github.com/YunHsiao/glslang/tree/build)
     linux:      11.5.0
     openharmony:11.5.0 (commit: 1978c76)
     
-swig ( Built using https://github.com/cocos/swig/tree/cocos-se, executable files are downloaded from https://github.com/cocos/swig/releases/tag/cocos-v1.1.2 )
-    win64:      cocos-v1.1.2 (commit: 5c7c430)
-    mac:        cocos-v1.1.2 (commit: 5c7c430)
-    linux:      cocos-v1.1.2 (commit: 5c7c430)
+swig ( Built using https://github.com/cocos/swig/tree/cocos-se, executable files are downloaded from https://github.com/cocos/swig/releases/tag/cocos-v1.1.4 )
+    win64:      cocos-v1.1.4 (commit: 9807544)
+    mac:        cocos-v1.1.4 (commit: 9807544)
+    linux:      cocos-v1.1.4 (commit: 9807544)

win64/bin/effect-checker/macros.ini

@@ -0,0 +1,248 @@
+;添加项目时需要仿照[不带路径的文件名|备注]的格式添加一行标题
+;文件名相同而备注不同的视为多套配置, 此配置为最优先
+;将common.chunk改坏保存,Creator中会有编译错误,展开代码,将前面所有的#define语句复制到标题行的下方
+
+;这个是公用的，如果没有特殊的宏集合，会自动查找此处
+[common|前向BasePass效果全开]
+2 #define CC_DEVICE_SUPPORT_FLOAT_TEXTURE 1
+3 #define CC_DEVICE_MAX_FRAGMENT_UNIFORM_VECTORS 1024
+4 #define CC_DEVICE_MAX_VERTEX_UNIFORM_VECTORS 1024
+5 #define CC_EFFECT_USED_VERTEX_UNIFORM_VECTORS 128
+6 #define CC_EFFECT_USED_FRAGMENT_UNIFORM_VECTORS 128
+7 #define CC_DEVICE_CAN_BENEFIT_FROM_INPUT_ATTACHMENT 0
+8 #define CC_ENABLE_CLUSTERED_LIGHT_CULLING 0
+9 #define CC_USE_MORPH 1
+10 #define CC_MORPH_TARGET_COUNT 2
+11 #define CC_MORPH_PRECOMPUTED 1
+12 #define CC_MORPH_TARGET_HAS_POSITION 1
+13 #define CC_MORPH_TARGET_HAS_NORMAL 1
+14 #define CC_MORPH_TARGET_HAS_TANGENT 1
+15 #define CC_USE_SKINNING 1
+16 #define CC_USE_BAKED_ANIMATION 1
+18 #define USE_BATCHING 0
+21 #define CC_FORWARD_ADD 0
+22 #define CC_RECEIVE_SHADOW 1
+30 #define CC_ENABLE_DIR_SHADOW 1
+50 #define CC_FOG_LINEAR 0
+51 #define CC_FOG_EXP 1
+52 #define CC_FOG_EXP_SQUARED 2
+53 #define CC_FOG_LAYERED 3
+54 #define CC_FOG_NONE 4
+43 #define CC_PIPELINE_TYPE 0
+44 #define CC_FORCE_FORWARD_SHADING 1
+45 #define CC_SUPPORT_CASCADED_SHADOW_MAP 1
+46 #define CC_DIR_SHADOW_PCF_TYPE 1
+
+[common|前向AddPass效果全开]
+2 #define CC_DEVICE_SUPPORT_FLOAT_TEXTURE 1
+3 #define CC_DEVICE_MAX_FRAGMENT_UNIFORM_VECTORS 1024
+4 #define CC_DEVICE_MAX_VERTEX_UNIFORM_VECTORS 1024
+5 #define CC_EFFECT_USED_VERTEX_UNIFORM_VECTORS 128
+6 #define CC_EFFECT_USED_FRAGMENT_UNIFORM_VECTORS 128
+7 #define CC_DEVICE_CAN_BENEFIT_FROM_INPUT_ATTACHMENT 0
+8 #define CC_ENABLE_CLUSTERED_LIGHT_CULLING 0
+9 #define CC_USE_MORPH 1
+10 #define CC_MORPH_TARGET_COUNT 2
+11 #define CC_MORPH_PRECOMPUTED 1
+12 #define CC_MORPH_TARGET_HAS_POSITION 1
+13 #define CC_MORPH_TARGET_HAS_NORMAL 1
+14 #define CC_MORPH_TARGET_HAS_TANGENT 1
+15 #define CC_USE_SKINNING 1
+16 #define CC_USE_BAKED_ANIMATION 1
+22 #define CC_RECEIVE_SHADOW 1
+30 #define CC_ENABLE_DIR_SHADOW 1
+50 #define CC_FOG_LINEAR 0
+51 #define CC_FOG_EXP 1
+52 #define CC_FOG_EXP_SQUARED 2
+53 #define CC_FOG_LAYERED 3
+54 #define CC_FOG_NONE 4
+43 #define CC_PIPELINE_TYPE 0
+44 #define CC_FORCE_FORWARD_SHADING 1
+21 #define CC_FORWARD_ADD 1
+18 #define USE_BATCHING 0
+45 #define CC_SUPPORT_CASCADED_SHADOW_MAP 1
+46 #define CC_DIR_SHADOW_PCF_TYPE 1
+
+[common|延迟效果全开]
+2 #define CC_DEVICE_SUPPORT_FLOAT_TEXTURE 1
+3 #define CC_DEVICE_MAX_FRAGMENT_UNIFORM_VECTORS 1024
+4 #define CC_DEVICE_MAX_VERTEX_UNIFORM_VECTORS 1024
+5 #define CC_EFFECT_USED_VERTEX_UNIFORM_VECTORS 128
+6 #define CC_EFFECT_USED_FRAGMENT_UNIFORM_VECTORS 128
+7 #define CC_DEVICE_CAN_BENEFIT_FROM_INPUT_ATTACHMENT 0
+8 #define CC_ENABLE_CLUSTERED_LIGHT_CULLING 0
+9 #define CC_USE_MORPH 1
+10 #define CC_MORPH_TARGET_COUNT 2
+11 #define CC_MORPH_PRECOMPUTED 1
+12 #define CC_MORPH_TARGET_HAS_POSITION 1
+13 #define CC_MORPH_TARGET_HAS_NORMAL 1
+14 #define CC_MORPH_TARGET_HAS_TANGENT 1
+15 #define CC_USE_SKINNING 1
+16 #define CC_USE_BAKED_ANIMATION 1
+22 #define CC_RECEIVE_SHADOW 1
+30 #define CC_ENABLE_DIR_SHADOW 1
+50 #define CC_FOG_LINEAR 0
+51 #define CC_FOG_EXP 1
+52 #define CC_FOG_EXP_SQUARED 2
+53 #define CC_FOG_LAYERED 3
+54 #define CC_FOG_NONE 4
+43 #define CC_PIPELINE_TYPE 1
+44 #define CC_FORCE_FORWARD_SHADING 0
+21 #define CC_FORWARD_ADD 0
+18 #define USE_BATCHING 0
+45 #define CC_SUPPORT_CASCADED_SHADOW_MAP 1
+46 #define CC_DIR_SHADOW_PCF_TYPE 1
+
+[builtin-terrain.effect|前向效果全开]
+2 #define CC_DEVICE_SUPPORT_FLOAT_TEXTURE 1
+3 #define CC_DEVICE_MAX_FRAGMENT_UNIFORM_VECTORS 1024
+4 #define CC_DEVICE_MAX_VERTEX_UNIFORM_VECTORS 1024
+5 #define CC_EFFECT_USED_VERTEX_UNIFORM_VECTORS 128
+6 #define CC_EFFECT_USED_FRAGMENT_UNIFORM_VECTORS 128
+7 #define CC_DEVICE_CAN_BENEFIT_FROM_INPUT_ATTACHMENT 0
+8 #define CC_ENABLE_CLUSTERED_LIGHT_CULLING 0
+9 #define CC_USE_MORPH 0
+15 #define CC_USE_SKINNING 0
+16 #define CC_USE_BAKED_ANIMATION 0
+22 #define CC_RECEIVE_SHADOW 1
+30 #define CC_ENABLE_DIR_SHADOW 1
+43 #define CC_PIPELINE_TYPE 1
+44 #define CC_FORCE_FORWARD_SHADING 0
+21 #define CC_FORWARD_ADD 0
+18 #define USE_BATCHING 0
+19 #define USE_INSTANCING 0
+
+[instanced-color.effect|前向效果全开]
+2 #define USE_INSTANCING 1
+3 #define USE_BATCHING 1
+4 #define USE_LIGHTMAP 1
+5 #define CC_DEVICE_SUPPORT_FLOAT_TEXTURE 1
+6 #define CC_DEVICE_MAX_FRAGMENT_UNIFORM_VECTORS 1024
+7 #define CC_DEVICE_MAX_VERTEX_UNIFORM_VECTORS 1024
+8 #define CC_EFFECT_USED_VERTEX_UNIFORM_VECTORS 128
+9 #define CC_EFFECT_USED_FRAGMENT_UNIFORM_VECTORS 128
+10 #define CC_DEVICE_CAN_BENEFIT_FROM_INPUT_ATTACHMENT 0
+11 #define CC_ENABLE_CLUSTERED_LIGHT_CULLING 0
+12 #define CC_USE_MORPH 1
+13 #define CC_MORPH_TARGET_COUNT 2
+14 #define CC_MORPH_PRECOMPUTED 1
+15 #define CC_MORPH_TARGET_HAS_POSITION 1
+16 #define CC_MORPH_TARGET_HAS_NORMAL 1
+17 #define CC_MORPH_TARGET_HAS_TANGENT 1
+18 #define CC_USE_SKINNING 1
+19 #define CC_USE_BAKED_ANIMATION 1
+
+[builtin-reflection-deferred.effect|前向效果全开]
+2 #define CC_DEVICE_SUPPORT_FLOAT_TEXTURE 1
+3 #define CC_DEVICE_MAX_FRAGMENT_UNIFORM_VECTORS 1024
+4 #define CC_DEVICE_MAX_VERTEX_UNIFORM_VECTORS 1024
+5 #define CC_EFFECT_USED_VERTEX_UNIFORM_VECTORS 128
+6 #define CC_EFFECT_USED_FRAGMENT_UNIFORM_VECTORS 128
+7 #define CC_DEVICE_CAN_BENEFIT_FROM_INPUT_ATTACHMENT 0
+8 #define CC_ENABLE_CLUSTERED_LIGHT_CULLING 0
+9 #define CC_USE_MORPH 1
+10 #define CC_MORPH_TARGET_COUNT 2
+11 #define CC_MORPH_PRECOMPUTED 1
+12 #define CC_MORPH_TARGET_HAS_POSITION 1
+13 #define CC_MORPH_TARGET_HAS_NORMAL 1
+14 #define CC_MORPH_TARGET_HAS_TANGENT 1
+15 #define CC_USE_SKINNING 1
+16 #define CC_USE_BAKED_ANIMATION 1
+21 #define CC_FORWARD_ADD 1
+22 #define CC_RECEIVE_SHADOW 1
+27 #define CC_ENABLE_DIR_SHADOW 1
+
+
+[deferred-lighting.effect|前向效果全开]
+2 #define CC_DEVICE_SUPPORT_FLOAT_TEXTURE 1
+3 #define CC_DEVICE_MAX_FRAGMENT_UNIFORM_VECTORS 1024
+4 #define CC_DEVICE_MAX_VERTEX_UNIFORM_VECTORS 1024
+5 #define CC_EFFECT_USED_VERTEX_UNIFORM_VECTORS 128
+6 #define CC_EFFECT_USED_FRAGMENT_UNIFORM_VECTORS 128
+7 #define CC_DEVICE_CAN_BENEFIT_FROM_INPUT_ATTACHMENT 0
+8 #define CC_ENABLE_CLUSTERED_LIGHT_CULLING 0
+9 #define CC_RECEIVE_SHADOW 1
+13 #define CC_FORWARD_ADD 1
+14 #define CC_ENABLE_DIR_SHADOW 1
+16 #define CC_PIPELINE_TYPE 0
+17 #define CC_FORCE_FORWARD_SHADING 1
+
+[skybox|前向效果全开]
+2 #define CC_DEVICE_SUPPORT_FLOAT_TEXTURE 1
+3 #define CC_DEVICE_MAX_FRAGMENT_UNIFORM_VECTORS 1024
+4 #define CC_DEVICE_MAX_VERTEX_UNIFORM_VECTORS 1024
+5 #define CC_EFFECT_USED_VERTEX_UNIFORM_VECTORS 128
+6 #define CC_EFFECT_USED_FRAGMENT_UNIFORM_VECTORS 128
+7 #define CC_DEVICE_CAN_BENEFIT_FROM_INPUT_ATTACHMENT 0
+8 #define CC_ENABLE_CLUSTERED_LIGHT_CULLING 0
+
+[builtin-sprite.effect|前向效果全开]
+4 #define CC_DEVICE_SUPPORT_FLOAT_TEXTURE 1
+5 #define CC_DEVICE_MAX_FRAGMENT_UNIFORM_VECTORS 1024
+6 #define CC_DEVICE_MAX_VERTEX_UNIFORM_VECTORS 1024
+7 #define CC_EFFECT_USED_VERTEX_UNIFORM_VECTORS 128
+8 #define CC_EFFECT_USED_FRAGMENT_UNIFORM_VECTORS 128
+9 #define CC_DEVICE_CAN_BENEFIT_FROM_INPUT_ATTACHMENT 0
+10 #define CC_ENABLE_CLUSTERED_LIGHT_CULLING 0
+12 #define CC_USE_EMBEDDED_ALPHA 1
+
+[builtin-sprite-gpu.effect|前向效果全开]
+2 #define CC_DEVICE_SUPPORT_FLOAT_TEXTURE 1
+3 #define CC_DEVICE_MAX_FRAGMENT_UNIFORM_VECTORS 1024
+4 #define CC_DEVICE_MAX_VERTEX_UNIFORM_VECTORS 1024
+5 #define CC_EFFECT_USED_VERTEX_UNIFORM_VECTORS 128
+6 #define CC_EFFECT_USED_FRAGMENT_UNIFORM_VECTORS 128
+7 #define CC_DEVICE_CAN_BENEFIT_FROM_INPUT_ATTACHMENT 0
+8 #define CC_ENABLE_CLUSTERED_LIGHT_CULLING 0
+11 #define CC_USE_EMBEDDED_ALPHA 1
+
+[builtin-wireframe.effect|前向效果全开]
+2 #define CC_DEVICE_SUPPORT_FLOAT_TEXTURE 1
+3 #define CC_DEVICE_MAX_FRAGMENT_UNIFORM_VECTORS 1024
+4 #define CC_DEVICE_MAX_VERTEX_UNIFORM_VECTORS 1024
+5 #define CC_EFFECT_USED_VERTEX_UNIFORM_VECTORS 128
+6 #define CC_EFFECT_USED_FRAGMENT_UNIFORM_VECTORS 128
+7 #define CC_DEVICE_CAN_BENEFIT_FROM_INPUT_ATTACHMENT 0
+8 #define CC_ENABLE_CLUSTERED_LIGHT_CULLING 0
+9 #define CC_USE_MORPH 1
+10 #define CC_MORPH_TARGET_COUNT 2
+11 #define CC_MORPH_PRECOMPUTED 1
+12 #define CC_MORPH_TARGET_HAS_POSITION 1
+13 #define CC_MORPH_TARGET_HAS_NORMAL 1
+14 #define CC_MORPH_TARGET_HAS_TANGENT 1
+15 #define CC_USE_SKINNING 1
+16 #define CC_USE_BAKED_ANIMATION 1
+
+[planar-shadow.effect|前向效果全开]
+2 #define CC_DEVICE_SUPPORT_FLOAT_TEXTURE 1
+3 #define CC_DEVICE_MAX_FRAGMENT_UNIFORM_VECTORS 1024
+4 #define CC_DEVICE_MAX_VERTEX_UNIFORM_VECTORS 1024
+5 #define CC_EFFECT_USED_VERTEX_UNIFORM_VECTORS 128
+6 #define CC_EFFECT_USED_FRAGMENT_UNIFORM_VECTORS 128
+7 #define CC_DEVICE_CAN_BENEFIT_FROM_INPUT_ATTACHMENT 0
+8 #define CC_ENABLE_CLUSTERED_LIGHT_CULLING 0
+9 #define CC_USE_MORPH 1
+10 #define CC_MORPH_TARGET_COUNT 2
+11 #define CC_MORPH_PRECOMPUTED 1
+12 #define CC_MORPH_TARGET_HAS_POSITION 1
+13 #define CC_MORPH_TARGET_HAS_NORMAL 1
+14 #define CC_MORPH_TARGET_HAS_TANGENT 1
+15 #define CC_USE_SKINNING 1
+16 #define CC_USE_BAKED_ANIMATION 1
+
+[batched-unlit.effect|前向效果全开]
+2 #define CC_DEVICE_SUPPORT_FLOAT_TEXTURE 1
+3 #define CC_DEVICE_MAX_FRAGMENT_UNIFORM_VECTORS 1024
+4 #define CC_DEVICE_MAX_VERTEX_UNIFORM_VECTORS 1024
+5 #define CC_EFFECT_USED_VERTEX_UNIFORM_VECTORS 128
+6 #define CC_EFFECT_USED_FRAGMENT_UNIFORM_VECTORS 128
+7 #define CC_DEVICE_CAN_BENEFIT_FROM_INPUT_ATTACHMENT 0
+8 #define CC_ENABLE_CLUSTERED_LIGHT_CULLING 0
+9 #define CC_USE_MORPH 1
+10 #define CC_MORPH_TARGET_COUNT 2
+11 #define CC_MORPH_PRECOMPUTED 1
+12 #define CC_MORPH_TARGET_HAS_POSITION 1
+13 #define CC_MORPH_TARGET_HAS_NORMAL 1
+14 #define CC_MORPH_TARGET_HAS_TANGENT 1
+15 #define CC_USE_SKINNING 1
+16 #define CC_USE_BAKED_ANIMATION 1