sync on 2026/06/27, rev 8a3630f36783b03aae39267a238c5aed3005fa05

Author: NicSavichev

DagorEngine.rev.txt

@@ -1 +1 @@
-b56bb083a422680afc47c84cabba44a7af5b9721
+8a3630f36783b03aae39267a238c5aed3005fa05

README.md

@@ -49,11 +49,11 @@ 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 (as of 2026/06/20) from the CDN into the X:\develop\DagorEngine folder:
-* [tools-base.7z](https://dagorenginedata.cdn.gaijin.net/head-2026.06.20/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.06.13/outerSpace-devsrc.7z) - contains initial assets for OuterSpace sample project
-* [dngSceneViewer.7z](https://dagorenginedata.cdn.gaijin.net/head-2026.06.20/dngSceneViewer.7z) - contains binary data for east_district sample with dngSceneViewer (windows-x86_64 executables also included)
+You will need to download and extract additional binary files (as of 2026/06/27) from the CDN into the X:\develop\DagorEngine folder:
+* [tools-base.7z](https://dagorenginedata.cdn.gaijin.net/head-2026.06.27/tools-base.7z) - contains initial data for tools
+* [samples-base.7z](https://dagorenginedata.cdn.gaijin.net/head-2026.06.27/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.06.27/outerSpace-devsrc.7z) - contains initial assets for OuterSpace sample project
+* [dngSceneViewer.7z](https://dagorenginedata.cdn.gaijin.net/head-2026.06.27/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):
 
@@ -80,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/head-2026.06.20/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.06.27/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/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).
+If you are going to run samples unpack [samples-base.7z](https://dagorenginedata.cdn.gaijin.net/head-2026.06.27/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/head-2026.06.13/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.06.27/outerSpace-devsrc.7z) to DagorEngine root.
 
 Then run `build_all.py` in DagorEngine root.
 
@@ -125,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/head-2026.06.13/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.06.27/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-dshl/index/shaders.rst

@@ -375,6 +375,128 @@ These indices are then used to retrieve the corresponding texture and sampler fr
 
 This is what ``get_<texture_name>()`` essentialy does for you.
 
+.. _explicit-bindless-resources:
+
+---------------------------
+Explicit bindless resources
+---------------------------
+
+The ``@static*`` material textures above are an *implicit* bindless path: the
+material system owns the resource and packs its ``uint2 {texture, sampler}`` slot
+into the per-material cbuffer for you.
+
+``@bindless*`` postfixes are the *explicit* counterpart: you bind an arbitrary
+resource into a bindless heap yourself and pass the shader its slot index through
+an ``int`` shader variable. Texture and sampler are independent (one ``int`` slot
+each), and the resource is whatever C++/daFrameGraph registered in the bindless heap
+at that index, rather than a material texture slot.
+
+.. list-table::
+  :header-rows: 1
+
+  * - Postfix
+    - HLSL element type
+  * - @bindlessTex2D
+    - Texture2D
+  * - @bindlessTex3D
+    - Texture3D
+  * - @bindlessTexCube
+    - TextureCube
+  * - @bindlessTexArray
+    - Texture2DArray
+  * - @bindlessTexCubeArray
+    - TextureCubeArray
+  * - @bindlessSampler
+    - SamplerState
+  * - @bindlessByteBuffer
+    - ByteAddressBuffer
+
+The right-hand side of the declaration is an ``int`` shader variable holding the
+bindless slot index; ``-1`` means "no resource bound".
+
+For each ``@bindless*`` declaration the compiler generates two functions: ``get_<name>()``
+fetches the resource from its bindless heap by the slot index (returning the postfix's
+HLSL element type, so ``get_albedo_smp()`` is a ``SamplerState`` and
+``get_albedo_buffer()`` a ``ByteAddressBuffer``), and ``has_<name>()`` returns whether
+a resource is bound (``slot >= 0``). Optional resources must be guarded with
+``has_<name>()`` before calling ``get_<name>()``:
+
+.. code-block:: text
+
+    int albedo_bindless_index = -1;
+    int bindless_sampler_index = -1;
+
+    shader example_bindless
+    {
+      (ps) {
+        albedo_2d@bindlessTex2D = albedo_bindless_index;
+        albedo_smp@bindlessSampler = bindless_sampler_index;
+      }
+
+      hlsl(ps) {
+        float4 main_ps() : SV_Target0
+        {
+          if (!has_albedo_2d())
+            return float4(0, 0, 0, 1);
+
+          SamplerState smp = get_albedo_smp();
+          return get_albedo_2d().SampleLevel(smp, float2(0, 0), 0);
+        }
+      }
+    }
+
+.. note::
+  Unlike ``@static*`` material textures, ``@bindless*`` has no non-bindless fallback:
+  it requires bindless support to be enabled for the target. Using it for a target
+  without bindless enabled is a compile error.
+
+There is no sugar for ``StructuredBuffer<T>``: it needs a per-element type, while the
+shared heap is untyped. Declare such a heap by hand and pass the slot through a plain
+``@i1`` int instead. Heap spaces ``1-6`` (the third argument to ``BINDLESS_*_ARRAY``)
+are reserved by the ``@bindless*`` heaps (textures ``1-5``, ``ByteAddressBuffer`` ``6``);
+use ``7+`` for your own arrays.
+
+.. code-block:: text
+
+    int my_sbuffer_index = -1;
+
+    shader example_bindless_sbuffer
+    {
+      (ps) {
+        my_sbuffer_id@i1 = (my_sbuffer_index);
+      }
+
+      hlsl(ps) {
+        BINDLESS_BUF_ARRAY(StructuredBuffer<float4>, sbufArr, 7);
+
+        float4 main_ps() : SV_Target0
+        {
+          if (my_sbuffer_id < 0)
+            return float4(0, 0, 0, 1);
+          return sbufArr[my_sbuffer_id][0];
+        }
+      }
+    }
+
+The ``int`` slot variable is filled on the CPU side. Manually, the slot index comes
+from the bindless API in ``<drv/3d/dag_bindless.h>`` (see
+:doc:`/api-references/dagor-render/index/d3dAPI/Bindless`):
+``d3d::allocate_bindless_resource_range()`` / ``d3d::update_bindless_resource()`` (or
+the ``d3d::add_bindless_resource()`` shortcut). Pass the returned index to the shader
+variable:
+
+.. code-block:: cpp
+
+    #include <drv/3d/dag_bindless.h>
+
+    // allocate a slot and point it at the resource
+    uint32_t idx = d3d::add_bindless_resource(D3DResourceType::TEX, tex);
+    ShaderGlobal::set_int(get_shader_variable_id("albedo_bindless_index", true), idx);
+
+Alternatively, inside a frame graph node, daFrameGraph's ``bindlessShaderVar()`` request
+does the allocation and sets this variable for you. See
+:cpp:class:`dafg::VirtualResourceRequest` in :doc:`/api-references/dagor-render/index/daFrameGraph/declaringNodes`.
+
 -------
 Buffers
 -------

_docs/source/api-references/dagor-render/index/daFrameGraph/declaringNodes.rst

@@ -27,6 +27,30 @@ These must be used inside the declaration callback for specifying the following
  * What global state the node requires (e.g. shader blocks)
  * Additional metadata (multiplexing mode, priority, explicit dependencies, etc)
 
+.. _dafg-bindless-shader-var:
+
+.. rubric:: Bindless bindings
+
+Besides ``bindToShaderVar()``, a resource request can be bound *bindlessly*:
+the resource is registered in a bindless heap and its slot index is written into a
+named ``int`` shader variable (``-1`` when the resource is missing or the driver has
+no bindless support).
+
+.. code-block:: cpp
+
+   registry.read("your_tex").texture()
+     .atStage(dafg::Stage::PS_OR_CS)
+     .bindlessShaderVar("your_bindless_index");
+
+   registry.create("your_sampler")
+     .blob<d3d::SamplerHandle>(d3d::request_sampler(d3d::SamplerInfo{}))
+     .bindlessShaderVar("your_sampler_index");
+
+The shader consumes the index through the matching ``int`` variable, either via the
+``@bindless*`` DSHL sugar or a manual ``BINDLESS_*_ARRAY`` declaration. See
+:ref:`explicit-bindless-resources` in the DSHL reference. The full request API is
+documented in :cpp:class:`dafg::VirtualResourceRequest` below.
+
 .. doxygenclass:: dafg::Registry
   :project: daFrameGraph
   :members:

outerSpace/prog/gameBase/gamedata/templates/outer_space.entities.blk

@@ -664,6 +664,9 @@ water{
     water__level:r=0
     water__fft_resolution:i=7
     water__max_tessellation:i=4
+    water__fresnel_specular_intensity:r=0.02
+    water__fresnel_ambient_reflection:r=0.2
+    water__fresnel_reflection:r=0.5
     water__flowmap:b=yes
     water__has_slopes:b=no
     water__flowmap_tex:t=""
@@ -816,12 +819,8 @@ capsules_ao{
 
 film_grain_lut{
   _singleton:b=yes
-  film_grain_lut__wh:i=256
-  film_grain_lut__d:i=64
   film_grain_lut__gen_params:p4=2.5,0.5,1.0,64
 
-  _tracked:t="film_grain_lut__wh"
-  _tracked:t="film_grain_lut__d"
   _tracked:t="film_grain_lut__gen_params"
 
   film_grain_lut{

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

@@ -50,6 +50,7 @@ let private STD_WHITELIST : table<string> <- {
     "min", "max", "abs", "clamp", "saturate", "sign", "floor", "ceil", "round", "trunc", "frac",
     "sqrt", "rsqrt", "pow", "exp", "exp2", "log", "log2",
     "sin", "cos", "tan", "asin", "acos", "atan", "atan2", "sincos",
+    "radians", "degrees",   // lowered to `x * K` by flatten_opt (no opcode needed)
     "dot", "cross", "length", "normalize", "distance", "reflect", "refract",
     "lerp", "mix", "step", "smooth_step", "rcp", "mad",
     "float2", "float3", "float4", "int2", "int3", "int4", "uint2", "uint3", "uint4"
@@ -719,6 +720,8 @@ def public flatten_function(var func : FunctionPtr; whitelist : table<string>; m
             dse_pass(out)          // drop dead mask-kills (`__flat_live = false`) first…
             copy_prop_pass(out)    // inline single-def temps AND const-fold the masks they expose
                                    // (`__flat_live=true` → `true ? a:b` → a; `__flat_ret=c; return __flat_ret` → `return c`)
+            mask_const_prop_pass(out)  // flow-sensitive const-prop of the multi-def loop/iter masks:
+                                   // first unrolled iter unconditional (`true ? a:b → a`), `m = m && X → m = X`
             dse_pass(out)          // remove anything left dead (collapsed mask decls, folded temps)
             ssa_rename_pass(out)   // single-def-ify reassigned user locals → fold_body const-props the chain
         }
@@ -773,6 +776,14 @@ def public flatten_optimize(var func : FunctionPtr; barriers : table<string>; no
     return flatten_preshade_cse(func, barriers, no_fast_math, log_cse)
 }
 
+[macro_function]
+def public flatten_pack(var func : FunctionPtr; no_fast_math : bool = false) : bool {
+    //! Scalar-packing map-reduce re-roll (delegates to `pack_map_reduce`): recognize an unrolled
+    //! min/max reduction's N isomorphic scalar lanes and pack them into width-W vector ops + one
+    //! horizontal reduce. Run PRE-fold (before `flatten_fold`); re-infer after. no_fast_math skips it.
+    return pack_map_reduce(func, no_fast_math)
+}
+
 [macro_function]
 def public flatten_fuse(var func : FunctionPtr; no_fast_math : bool = false) : bool {
     //! PHASE_FUSED finishing pass (delegates to `fuse_body`): collapse same-vector lane sums into
@@ -894,6 +905,11 @@ def public flatten_fold_residuals(var func : FunctionPtr; no_fast_math : bool =
         unsafe {
             delete v
         }
+        // Statement-level (not a node pattern): a same-condition select-accumulation chain that
+        // fuse_select_chains should have collapsed to one select.
+        if (func.body is ExprBlock && has_fusable_select_chain(func.body as ExprBlock)) {
+            res |> push("an un-fused same-condition select chain (N selects should be 1)")
+        }
     }
     return <- res
 }