sync on 2026/04/30, rev de41bcbfb17ce9699b9e3a0c42ae6042624d2905

Author: NicSavichev

DagorEngine.rev.txt

@@ -1 +1 @@
-6ce20af09a08986d4932e3182f3a5c27457aff50
+de41bcbfb17ce9699b9e3a0c42ae6042624d2905

README.md

@@ -49,10 +49,14 @@ Restart the command line console to make the new environment variables available
 
 ## How to Build: Prebuilt Binaries
 
-You will need to download and extract additional binary files from the repository [https://github.com/GaijinEntertainment/DagorEngine/releases](https://github.com/GaijinEntertainment/DagorEngine/releases) into the X:\develop\DagorEngine folder:
+You will need to download and extract additional binary files (as of 2026/04/30) from the CDN into the X:\develop\DagorEngine folder:
+* [tools-base.7z](https://dagorenginedata.cdn.gaijin.net/head-2026.04.30/tools-base.7z) - contains initial data for tools
+* [samples-base.7z](https://dagorenginedata.cdn.gaijin.net/head-2026.04.30/samples-base.7z) - contains initial assets that will be compiled into binary files that will be loaded by the game (samples)
+* [outerSpace-devsrc.7z](https://dagorenginedata.cdn.gaijin.net/head-2026.04.30/outerSpace-devsrc.7z) - contains initial assets for OuterSpace sample project
+* [dngSceneViewer.7z](https://dagorenginedata.cdn.gaijin.net/head-2026.04.30/dngSceneViewer.7z) - contains binary data for east_district sample with dngSceneViewer (windows-x86_64 executables also included)
+
+More downloads in the repository [https://github.com/GaijinEntertainment/DagorEngine/releases](https://github.com/GaijinEntertainment/DagorEngine/releases) with prebuilt binaries (may be a bit outdate):
 
-* [tools-base.7z](https://dagorenginedata.cdn.gaijin.net/rel-fea0a2b3ae5acdb25e088e57a8fb1f77d5ba3e1d/tools-base.7z) - contains initial data for tools
-* [samples-base.7z](https://dagorenginedata.cdn.gaijin.net/rel-fea0a2b3ae5acdb25e088e57a8fb1f77d5ba3e1d/samples-base.7z) - contains initial assets that will be compiled into binary files that will be loaded the game
 * [tools-prebuilt-windows-x86_64.7z](https://dagorenginedata.cdn.gaijin.net/rel-fea0a2b3ae5acdb25e088e57a8fb1f77d5ba3e1d/tools-prebuilt-windows-x86_64.7z),
   [tools-prebuilt-linux-x86_64.tar.gz](https://dagorenginedata.cdn.gaijin.net/rel-fea0a2b3ae5acdb25e088e57a8fb1f77d5ba3e1d/tools-prebuilt-linux-x86_64.tar.gz),
   [tools-prebuilt-macOS.tar.gz](https://dagorenginedata.cdn.gaijin.net/rel-fea0a2b3ae5acdb25e088e57a8fb1f77d5ba3e1d/tools-prebuilt-macOS.tar.gz) - contains the prebuilt engine toolkit
@@ -76,11 +80,11 @@ X:\develop\DagorEngine\samples\testGI\game
 
 ## How to Build: Build from Source Code
 
-First unpack [tools-base.7z](https://dagorenginedata.cdn.gaijin.net/rel-fea0a2b3ae5acdb25e088e57a8fb1f77d5ba3e1d/tools-base.7z) to DagorEngine root to get mandatory binary files in their place.
+First unpack [tools-base.7z](https://dagorenginedata.cdn.gaijin.net/head-2026.04.30/tools-base.7z) to DagorEngine root to get mandatory binary files in their place.
 
-If you are going to run samples unpack [samples-base.7z](https://dagorenginedata.cdn.gaijin.net/rel-fea0a2b3ae5acdb25e088e57a8fb1f77d5ba3e1d/samples-base.7z) to DagorEngine root (if you plan to only build EXE and shaders these binary data are not mandatory).
+If you are going to run samples unpack [samples-base.7z](https://dagorenginedata.cdn.gaijin.net/head-2026.04.30/samples-base.7z) to DagorEngine root (if you plan to only build EXE and shaders these binary data are not mandatory).
 
-To build and run OuterSpace sample project unpack also [outerSpace-devsrc.7z](https://dagorenginedata.cdn.gaijin.net/rel-fea0a2b3ae5acdb25e088e57a8fb1f77d5ba3e1d/outerSpace-devsrc.7z) to DagorEngine root.
+To build and run OuterSpace sample project unpack also [outerSpace-devsrc.7z](https://dagorenginedata.cdn.gaijin.net/head-2026.04.30/outerSpace-devsrc.7z) to DagorEngine root.
 
 Then run `build_all.py` in DagorEngine root.
 
@@ -121,7 +125,7 @@ Example: `build_all.py project:dngSceneViewer code shaders` will build only code
   [Demos of a new Gaijin’s game showcase Dagor Engine power](https://gaijinent.com/news/demos-of-a-new-gaijins-game-showcase-dagor-engine-power)<br>
   [East District review on YouTube](https://youtu.be/miABl6aekBA)
 * Multiplayer sample: **Outer Space**<br>
-  [Code](https://github.com/GaijinEntertainment/DagorEngine/tree/main/outerSpace/prog) and source (develop) files [outerSpace-devsrc.7z](https://dagorenginedata.cdn.gaijin.net/rel-fea0a2b3ae5acdb25e088e57a8fb1f77d5ba3e1d/outerSpace-devsrc.7z) to be unpacked to DagorEngine root<br>
+  [Code](https://github.com/GaijinEntertainment/DagorEngine/tree/main/outerSpace/prog) and source (develop) files [outerSpace-devsrc.7z](https://dagorenginedata.cdn.gaijin.net/head-2026.04.30/outerSpace-devsrc.7z) to be unpacked to DagorEngine root<br>
   Prebuilt game (executables, shaders, vromfs, gameres) is available as [outerSpace-prebuilt-fullsrc.tar.gz](https://dagorenginedata.cdn.gaijin.net/rel-fea0a2b3ae5acdb25e088e57a8fb1f77d5ba3e1d/outerSpace-prebuilt-fullsrc.tar.gz)
 
 ### Documentation

_docs/source/api-references/dagor-render/index/shaders/compute_shaders.rst

@@ -0,0 +1,83 @@
+Compute Shaders
+=================================================
+
+Overview
+--------
+
+The compute shader API provides two classes for dispatching GPU compute work:
+
+- :cpp:class:`ComputeShaderElement` -- low-level compute shader element with full control
+  over parameter binding, dispatch modes, and GPU pipeline selection.
+- :cpp:class:`ComputeShader` -- lightweight RAII wrapper for the common case of
+  creating a shader by name and dispatching work.
+
+.. warning::
+
+   Avoid using :cpp:class:`ComputeShaderElement` directly. It returns a raw
+   pointer from :cpp:func:`new_compute_shader` that must be manually deleted,
+   making it easy to leak memory. Prefer :cpp:class:`ComputeShader` which
+   manages lifetime automatically via ``eastl::unique_ptr``.
+
+Usage
+-----
+
+Creating a compute shader
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Use the :cpp:class:`ComputeShader` RAII wrapper:
+
+.. code-block:: cpp
+
+   #include <shaders/dag_computeShaders.h>
+
+   ComputeShader cs("my_compute_shader");
+   if (cs)
+     cs.dispatchThreads(width, height, 1);
+
+Setting parameters
+~~~~~~~~~~~~~~~~~~
+
+Shader parameters are set via variable IDs obtained from
+:cpp:func:`get_shader_variable_id`:
+
+.. code-block:: cpp
+
+   int varId = get_shader_variable_id("some_param");
+   cs->set_color4_param(varId, Color4(1, 0, 0, 1));
+   cs->set_texture_param(texVarId, textureId);
+
+Dispatching work
+~~~~~~~~~~~~~~~~
+
+There are three dispatch modes:
+
+- **By thread groups** -- :cpp:func:`ComputeShaderElement::dispatch` dispatches
+  the specified number of thread groups directly.
+- **By total threads** -- :cpp:func:`ComputeShaderElement::dispatchThreads`
+  takes the desired total thread count and automatically divides by the shader's
+  thread group sizes (rounding up).
+- **Indirect** -- :cpp:func:`ComputeShaderElement::dispatch_indirect` reads
+  dispatch arguments from a GPU buffer. The buffer must contain 3 ``uint32_t``
+  values (``groupCountX``, ``groupCountY``, ``groupCountZ``) at the given byte
+  offset. The buffer must be created with ``SBCF_BIND_UNORDERED`` and
+  ``SBCF_MISC_DRAWINDIRECT`` flags (e.g. via ``d3d::buffers::create_ua_indirect``
+  with ``Indirect::Dispatch``). When storing multiple dispatch entries in a single
+  buffer, the byte offset should be a multiple of ``DISPATCH_INDIRECT_BUFFER_SIZE``
+  (12 bytes).
+
+.. code-block:: cpp
+
+   // Dispatch by thread groups
+   cs->dispatch(groupsX, groupsY, groupsZ);
+
+   // Dispatch by total thread count (auto-divides by thread group size)
+   cs->dispatchThreads(totalX, totalY, totalZ);
+
+   // Indirect dispatch from a GPU buffer
+   cs->dispatch_indirect(argsBuffer, byteOffset);
+
+API Reference
+-------------
+
+.. doxygenfile:: dag_computeShaders.h
+  :project: shaders

prog/1stPartyLibs/daScript/daslib/debug.das

@@ -2480,6 +2480,9 @@ def private auto_start_debug() {
     if ((is_in_aot() && loads_itself()) || is_in_debug_agent_creation() || !is_compiling_macros_in_module("debug") || is_in_completion()) {
         return
     }
+    let args <- get_command_line_arguments()
+    if (has_value(args, "--no-das-debug")) return
+
     this_context().category |= context_category_flags.debugger_attached
     set_single_step(this_context(), !use_instruments() || wait_debugger())
     if (!has_debug_agent_context("~debug")) {

prog/1stPartyLibs/quirrel/brick_fuzzer/code_bricks.py

@@ -5115,6 +5115,126 @@ class Brick:
           "    let $out0_th = newthread($out0_obj.do_yield)\n"
           "    $out0 = $out0_th.call($out0_obj)\n"
           "  } catch($out0_e) { $out0 = $in0 }"),
+
+    # ---- foreach destructuring (parser desugars to surrogate val + body destr) ----
+    Brick("foreach_destruct_table",
+          [Slot("in0", INT), Slot("in1", INT)],
+          [Slot("out0", INT)],
+          "local $out0 = 0\n"
+          "  foreach ({a, b} in [{a = $in0, b = $in1}, {a = $in1, b = $in0}])\n"
+          "    $out0 += a + b"),
+
+    Brick("foreach_destruct_array",
+          [Slot("in0", INT), Slot("in1", INT)],
+          [Slot("out0", INT)],
+          "local $out0 = 0\n"
+          "  foreach ([a, b] in [[$in0, $in1], [$in1, $in0]])\n"
+          "    $out0 += a - b"),
+
+    Brick("foreach_destruct_idx_table",
+          [Slot("in0", INT), Slot("in1", INT)],
+          [Slot("out0", INT)],
+          "local $out0 = 0\n"
+          "  foreach (i, {x} in [{x = $in0}, {x = $in1}])\n"
+          "    $out0 += i * 10 + x"),
+
+    Brick("foreach_destruct_default",
+          [Slot("in0", INT)],
+          [Slot("out0", INT)],
+          "local $out0 = 0\n"
+          "  foreach ({m = $INT} in [{m = $in0}, {}, {m = $in0 + 1}])\n"
+          "    $out0 += m"),
+
+    Brick("foreach_destruct_typed_default",
+          [Slot("in0", INT)],
+          [Slot("out0", INT)],
+          "local $out0 = 0\n"
+          "  foreach ({k: int = $INT} in [{}, {k = $in0}, {}])\n"
+          "    $out0 += k"),
+
+    Brick("foreach_destruct_array_default",
+          [Slot("in0", INT)],
+          [Slot("out0", INT)],
+          "local $out0 = 0\n"
+          "  foreach ([a, b = $INT] in [[$in0], [$in0, $in0 + 1]])\n"
+          "    $out0 += a + b"),
+
+    Brick("foreach_destruct_empty_table",
+          [Slot("in0", INT)],
+          [Slot("out0", INT)],
+          "local $out0 = 0\n"
+          "  foreach ({} in [{a = $in0}, {b = $in0}, {}])\n"
+          "    $out0++"),
+
+    Brick("foreach_destruct_empty_array",
+          [Slot("in0", INT)],
+          [Slot("out0", INT)],
+          "local $out0 = 0\n"
+          "  foreach ([] in [[$in0, $in0], [$in0]])\n"
+          "    $out0++"),
+
+    Brick("foreach_destruct_nested",
+          [Slot("in0", INT), Slot("in1", INT)],
+          [Slot("out0", INT)],
+          "local $out0 = 0\n"
+          "  let $out0_rows = [{xs = [{v = $in0}, {v = $in1}]}, {xs = [{v = $in1}]}]\n"
+          "  foreach ({xs} in $out0_rows)\n"
+          "    foreach ({v} in xs) $out0 += v"),
+
+    # ---- per-iter capture: closures store v / i and call after loop ----
+    Brick("foreach_capture_val",
+          [Slot("in0", INT)],
+          [Slot("out0", INT)],
+          "local $out0 = 0\n"
+          "  let $out0_fns = []\n"
+          "  foreach (v in [$in0, $in0 + 1, $in0 + 2])\n"
+          "    $out0_fns.append(@() v)\n"
+          "  foreach (f in $out0_fns) $out0 += f()"),
+
+    Brick("foreach_capture_idx_val",
+          [Slot("in0", INT)],
+          [Slot("out0", INT)],
+          "local $out0 = 0\n"
+          "  let $out0_fns = []\n"
+          "  foreach (i, v in [$in0, $in0 * 2, $in0 * 3])\n"
+          "    $out0_fns.append(@() i * 100 + v)\n"
+          "  foreach (f in $out0_fns) $out0 += f()"),
+
+    Brick("foreach_capture_destruct_field",
+          [Slot("in0", INT)],
+          [Slot("out0", INT)],
+          "local $out0 = 0\n"
+          "  let $out0_fns = []\n"
+          "  foreach ({v} in [{v = $in0}, {v = $in0 + 1}, {v = $in0 + 2}])\n"
+          "    $out0_fns.append(@() v)\n"
+          "  foreach (f in $out0_fns) $out0 += f()"),
+
+    Brick("foreach_capture_idx_destruct",
+          [Slot("in0", INT)],
+          [Slot("out0", INT)],
+          "local $out0 = 0\n"
+          "  let $out0_fns = []\n"
+          "  foreach (i, {x} in [{x = $in0}, {x = $in0 + 1}])\n"
+          "    $out0_fns.append(@() i + x)\n"
+          "  foreach (f in $out0_fns) $out0 += f()"),
+
+    Brick("foreach_capture_no_inner_capture",
+          [Slot("in0", INT)],
+          [Slot("out0", INT)],
+          "local $out0 = 0\n"
+          "  let $out0_fns = []\n"
+          "  foreach (v in [$in0, $in0 + 1])\n"
+          "    $out0_fns.append(function() { let local_v = $INT; return local_v })\n"
+          "  foreach (f in $out0_fns) $out0 += f()"),
+
+    Brick("foreach_destruct_default_with_closure",
+          [Slot("in0", INT)],
+          [Slot("out0", INT)],
+          "local $out0 = 0\n"
+          "  let $out0_factor = $in0\n"
+          "  foreach ({n = (function(){ return $out0_factor + $INT })()}\n"
+          "           in [{n = $in0}, {}, {n = $in0 + 1}])\n"
+          "    $out0 += n"),
 ]
 
 

prog/1stPartyLibs/quirrel/quirrel/doc/source/reference/language/destructuring_assignment.rst

@@ -54,3 +54,41 @@ Example
 Default values in destructured parameters are applied when the corresponding
 slot is missing in the passed argument. Type annotations may be used on individual
 destructured elements in the same way as for regular parameters.
+
+Empty patterns ``{}`` and ``[]`` are accepted and simply discard the argument.
+
+
+Destructuring in ``foreach`` loops
+==================================
+
+The iteration value of a ``foreach`` loop may be a destructuring pattern. Both
+table-style ``{...}`` and array-style ``[...]`` patterns are supported, with or
+without an index variable. Default values and type annotations work the same
+way as in :ref:`destructuring_assignment` and in function parameters.
+
+Example
+::
+
+   let pairs = [[1, 2], [3, 4]]
+   foreach ([a, b] in pairs)
+     println(a, b)
+
+   let rows = [{x = 1, y = 2}, {x = 3, y = 4}]
+   foreach (i, {x, y} in rows)
+     println(i, x, y)
+
+   // defaults applied when a slot is missing
+   foreach ({x = -1, y = -2} in [{x = 10}, {y = 20}, {}])
+     println(x, y)
+
+   // typed defaults
+   foreach ({x: int = 0, y: int|null = null} in [{x = 5}, {y = 7}])
+     println(x, y)
+
+   // empty patterns are allowed (the iteration value is discarded)
+   foreach ({} in rows)
+     println("tick")
+
+The destructured bindings are scoped to the loop body. Each iteration produces
+fresh bindings, so closures captured inside the body observe the value from
+their own iteration.

prog/1stPartyLibs/quirrel/quirrel/doc/source/reference/language/statements.rst

@@ -212,7 +212,8 @@ foreach
 
 ::
 
-    'foreach' '(' [index_id','] value_id 'in' exp ')' stat
+    value_pat   := id | '[' destr_fields ']' | '{' destr_fields '}'
+    'foreach' '(' [index_id','] value_pat 'in' exp ')' stat
 
 Executes a statement for every element contained in an array, table, class, string or generator.
 If exp is a generator it will be resumed every iteration as long as it is alive; the value will
@@ -226,6 +227,22 @@ from 0.::
     foreach (val in a)
         println ($"value={val}")
 
+The iteration value may also be a destructuring pattern, in which case the
+yielded value is unpacked into the named bindings on each iteration.
+Default values and type annotations are supported in the same way as for
+:ref:`destructuring assignments <destructuring_assignment>`.::
+
+    foreach ([a, b] in [[1, 2], [3, 4]])
+        println(a, b)
+
+    foreach (i, {x, y} in [{x = 1, y = 2}, {x = 3, y = 4}])
+        println(i, x, y)
+
+    foreach ({n: int = 0} in [{n = 5}, {}])
+        println(n)
+
+See :ref:`destructuring_assignment` for the full pattern syntax.
+
 -------
 break
 -------

prog/1stPartyLibs/quirrel/quirrel/include/squirrel.h

@@ -66,7 +66,7 @@ namespace SQCompilation
 #include <stdio.h>
 
 #define SQUIRREL_VERSION_NUMBER_MAJOR 4
-#define SQUIRREL_VERSION_NUMBER_MINOR 19
+#define SQUIRREL_VERSION_NUMBER_MINOR 20
 #define SQUIRREL_VERSION_NUMBER_PATCH 0
 
 #define SQ_STRINGIFY_HELPER(x) #x

prog/1stPartyLibs/quirrel/quirrel/sq/sq_test_natives.cpp

@@ -1,7 +1,7 @@
 // Test native module for native field testing.
 // Registers "test.native" module with NativeVec class.
 
-#include <sqmodules/sqmodules.h>
+#include <sqmodules.h>
 #include <sqrat.h>
 #include <string.h>
 #include <stdio.h>

prog/1stPartyLibs/quirrel/quirrel/sqrat/include/sqrat/sqratUtil.h

@@ -70,6 +70,7 @@ EA_DISABLE_ALL_VC_WARNINGS()
 #else
 # include <string>
 # include <string_view>
+# include <vector>
 # include <unordered_map>
 # include <unordered_set>
 # include <memory>