stuff

swizzle! struct indexing!
2024-03-06 15:02:15 -08:00 · 2024-02-28 16:05:28 -08:00 · 2024-02-27 17:04:25 -08:00 · 2024-02-27 15:39:40 -08:00 · 2024-02-27 14:31:32 -08:00 · 2024-02-27 12:54:41 -08:00
165 changed files with 5975 additions and 681 deletions
@@ -1,7 +1,8 @@
 ;;; Directory Local Variables            -*- no-byte-compile: t -*-
 ;;; For more information see (info "(emacs) Directory Variables")

-((c++-mode . ((c-file-style . "filament")
+((c++-mode . ((eglot-ignored-server-capabilities . (:documentFormattingProvider))
+              (c-file-style . "filament")
              (apheleia-inhibit . t)))
 (c-mode . ((c-file-style . "filament")
            (apheleia-inhibit . t))))
@@ -634,9 +634,9 @@ function(combine_static_libs TARGET OUTPUT DEPS)
    # Loop through the dependent libraries and query their location on disk.
    set(DEPS_FILES )
    foreach(DEPENDENCY ${DEPS})
-        if(TARGET ${DEPENDENCY})
+        if (TARGET ${DEPENDENCY})
            get_property(dep_type TARGET ${DEPENDENCY} PROPERTY TYPE)
-            if(dep_type STREQUAL "STATIC_LIBRARY")
+            if (dep_type STREQUAL "STATIC_LIBRARY")
                list(APPEND DEPS_FILES "$<TARGET_FILE:${DEPENDENCY}>")
            endif()
        endif()
@@ -721,7 +721,6 @@ add_subdirectory(${LIBRARIES}/filabridge)
 add_subdirectory(${LIBRARIES}/filaflat)
 add_subdirectory(${LIBRARIES}/filagui)
 add_subdirectory(${LIBRARIES}/filameshio)
-add_subdirectory(${LIBRARIES}/geometry)
 add_subdirectory(${LIBRARIES}/gltfio)
 add_subdirectory(${LIBRARIES}/ibl)
 add_subdirectory(${LIBRARIES}/iblprefilter)
@@ -749,12 +748,16 @@ add_subdirectory(${EXTERNAL}/jsmn/tnt)
 add_subdirectory(${EXTERNAL}/stb/tnt)
 add_subdirectory(${EXTERNAL}/getopt)

+# Note that this has to be placed after mikktspace in order for combine_static_libs to work.
+add_subdirectory(${LIBRARIES}/geometry)
+
 if (FILAMENT_BUILD_FILAMAT OR IS_HOST_PLATFORM)
    # spirv-tools must come before filamat, as filamat relies on the presence of the
    # spirv-tools_SOURCE_DIR variable.
    add_subdirectory(${EXTERNAL}/spirv-tools)
    add_subdirectory(${EXTERNAL}/glslang/tnt)
    add_subdirectory(${EXTERNAL}/spirv-cross/tnt)
+    add_subdirectory(${LIBRARIES}/astrict)
    add_subdirectory(${LIBRARIES}/filamat)

    # the material debugger requires filamat
@@ -7,5 +7,3 @@ for next branch cut* header.
 appropriate header in [RELEASE_NOTES.md](./RELEASE_NOTES.md).

 ## Release notes for next branch cut
-
- Metal: fix some shader artifacts by disabling fast math optimizations.
@@ -31,7 +31,7 @@ repositories {
 }

 dependencies {
-    implementation 'com.google.android.filament:filament-android:1.49.3'
+    implementation 'com.google.android.filament:filament-android:1.50.0'
 }
 ```

@@ -51,7 +51,7 @@ Here are all the libraries available in the group `com.google.android.filament`:
 iOS projects can use CocoaPods to install the latest release:

 ```shell
-pod 'Filament', '~> 1.49.3'
+pod 'Filament', '~> 1.50.0'
 ```

 ### Snapshots
@@ -7,6 +7,12 @@ A new header is inserted each time a *tag* is created.
 Instead, if you are authoring a PR for the main branch, add your release note to
 [NEW_RELEASE_NOTES.md](./NEW_RELEASE_NOTES.md).

+## v1.50.1
+
+- Metal: fix some shader artifacts by disabling fast math optimizations.
+- backend: remove `atan2` overload which had a typo and wasn't useful. Fixes b/320856413.
+- utils: remove usages of `SpinLock`. Fixes b/321101014.
+
 ## v1.50.0
 - engine: TAA now supports 4x upscaling [BETA] [⚠️ **New Material Version**]

@@ -1882,7 +1882,7 @@ public class View {
     * Options for Temporal Anti-aliasing (TAA)
     * Most TAA parameters are extremely costly to change, as they will trigger the TAA post-process
     * shaders to be recompiled. These options should be changed or set during initialization.
-     * `filterWidth`, `feedback` and `jitterPattern`, however, could be changed at any time.
+     * `filterWidth`, `feedback` and `jitterPattern`, however, can be changed at any time.
     *
     * `feedback` of 0.1 effectively accumulates a maximum of 19 samples in steady state.
     * see "A Survey of Temporal Antialiasing Techniques" by Lei Yang and all for more information.
@@ -1925,6 +1925,7 @@ public class View {
            UNIFORM_HELIX_X4,
            HALTON_23_X8,
            HALTON_23_X16,
+            HALTON_23_X32,
        }

        /**
@@ -1939,6 +1940,10 @@ public class View {
         * texturing lod bias (typically -1 or -2)
         */
        public float lodBias = -1.0f;
+        /**
+         * post-TAA sharpen, especially useful when upscaling is true.
+         */
+        public float sharpness = 0.0f;
        /**
         * enables or disables temporal anti-aliasing
         */
@@ -1,5 +1,5 @@
 GROUP=com.google.android.filament
-VERSION_NAME=1.49.3
+VERSION_NAME=1.50.0

 POM_DESCRIPTION=Real-time physically based rendering engine for Android.

@@ -238,6 +238,7 @@ set(MATERIAL_SRCS
        src/materials/resolveDepth.mat
        src/materials/separableGaussianBlur.mat
        src/materials/skybox.mat
+        src/materials/shadowmap.mat
        src/materials/ssao/bilateralBlur.mat
        src/materials/ssao/bilateralBlurBentNormals.mat
        src/materials/ssao/mipmapDepth.mat
@@ -23,7 +23,6 @@
 #include <utils/ostream.h>

 #include <stddef.h>
-#include <stdint.h>

 namespace filament::backend {

@@ -17,8 +17,6 @@
 #ifndef TNT_FILAMENT_BACKEND_CALLBACKHANDLER_H
 #define TNT_FILAMENT_BACKEND_CALLBACKHANDLER_H

-#include <utils/compiler.h>
-
 namespace filament::backend {

 /**
@@ -28,7 +28,8 @@

 #include <math/vec4.h>

-#include <array>    // FIXME: STL headers are not allowed in public headers
+#include <array>        // FIXME: STL headers are not allowed in public headers
+#include <type_traits>  // FIXME: STL headers are not allowed in public headers

 #include <stddef.h>
 #include <stdint.h>
@@ -17,16 +17,14 @@
 #ifndef TNT_FILAMENT_BACKEND_HANDLE_H
 #define TNT_FILAMENT_BACKEND_HANDLE_H

-#include <utils/compiler.h>
 #if !defined(NDEBUG)
-#include <utils/Log.h>
+#include <utils/ostream.h>
 #endif
 #include <utils/debug.h>

-#include <stdint.h>
+#include <type_traits> // FIXME: STL headers are not allowed in public headers

-#include <limits>
-#include <type_traits>
+#include <stdint.h>

 namespace filament::backend {

@@ -54,7 +52,7 @@ struct HwVertexBuffer;
 class HandleBase {
 public:
    using HandleId = uint32_t;
-    static constexpr const HandleId nullid = HandleId{ std::numeric_limits<HandleId>::max() };
+    static constexpr const HandleId nullid = HandleId{ UINT32_MAX };

    constexpr HandleBase() noexcept: object(nullid) {}

@@ -20,7 +20,7 @@
 #include <backend/DriverEnums.h>
 #include <backend/Handle.h>

-#include <limits>
+#include <utils/ostream.h>

 #include <stdint.h>

@@ -33,10 +33,7 @@ struct PipelineState {
    RasterState rasterState;
    StencilState stencilState;
    PolygonOffset polygonOffset;
-    Viewport scissor{ 0, 0,
-                      (uint32_t)std::numeric_limits<int32_t>::max(),
-                      (uint32_t)std::numeric_limits<int32_t>::max()
-    };
+    Viewport scissor{ 0, 0, (uint32_t)INT32_MAX, (uint32_t)INT32_MAX };
 };

 } // namespace filament::backend
@@ -24,6 +24,7 @@

 #include <utils/compiler.h>
 #include <utils/debug.h>
+#include <utils/ostream.h>

 #include <stddef.h>
 #include <stdint.h>
@@ -19,11 +19,11 @@
 #ifndef TNT_FILAMENT_BACKEND_PLATFORM_H
 #define TNT_FILAMENT_BACKEND_PLATFORM_H

-#include <backend/DriverEnums.h>
-
 #include <utils/compiler.h>
 #include <utils/Invocable.h>

+#include <stddef.h>
+
 namespace filament::backend {

 class Driver;
@@ -41,18 +41,24 @@ public:
    struct Stream {};

    struct DriverConfig {
-        /*
-         * size of handle arena in bytes. Setting to 0 indicates default value is to be used.
+        /**
+         * Size of handle arena in bytes. Setting to 0 indicates default value is to be used.
         * Driver clamps to valid values.
         */
        size_t handleArenaSize = 0;

-        /*
-         * this number of most-recently destroyed textures will be tracked for use-after-free.
+        /**
+         * This number of most-recently destroyed textures will be tracked for use-after-free.
         * Throws an exception when a texture is freed but still bound to a SamplerGroup and used in
         * a draw call. 0 disables completely. Currently only respected by the Metal backend.
         */
        size_t textureUseAfterFreePoolSize = 0;
+
+        /**
+         * Set to `true` to forcibly disable parallel shader compilation in the backend.
+         * Currently only honored by the GL backend.
+         */
+        bool disableParallelShaderCompile = false;
    };

    Platform() noexcept;
@@ -21,8 +21,7 @@

 #include <utils/compiler.h>

-namespace filament {
-namespace backend {
+namespace filament::backend {

 /**
 * A PresentCallable is a callable object that, when called, schedules a frame for presentation on
@@ -98,7 +97,6 @@ private:
 */
 using FrameFinishedCallback UTILS_DEPRECATED = void(*)(PresentCallable callable, void* user);

-} // namespace backend
-} // namespace filament
+} // namespace filament::backend

 #endif // TNT_FILAMENT_BACKEND_PRESENTCALLABLE
@@ -17,17 +17,19 @@
 #ifndef TNT_FILAMENT_BACKEND_PRIVATE_PROGRAM_H
 #define TNT_FILAMENT_BACKEND_PRIVATE_PROGRAM_H

-#include <utils/compiler.h>
 #include <utils/CString.h>
 #include <utils/FixedCapacityVector.h>
 #include <utils/Invocable.h>
-#include <utils/Log.h>
 #include <utils/ostream.h>

 #include <backend/DriverEnums.h>

-#include <array>
-#include <variant>
+#include <array>    // FIXME: STL headers are not allowed in public headers
+#include <utility>  // FIXME: STL headers are not allowed in public headers
+#include <variant>  // FIXME: STL headers are not allowed in public headers
+
+#include <stddef.h>
+#include <stdint.h>

 namespace filament::backend {

@@ -24,9 +24,6 @@

 #include <utils/compiler.h>

-#include <stddef.h>
-#include <stdint.h>
-
 namespace filament::backend {

 struct UTILS_PUBLIC SamplerDescriptor {
@@ -17,9 +17,11 @@
 #ifndef TNT_FILAMENT_BACKEND_TARGETBUFFERINFO_H
 #define TNT_FILAMENT_BACKEND_TARGETBUFFERINFO_H

-#include <backend/DriverEnums.h>
 #include <backend/Handle.h>

+#include <utils/ostream.h>
+
+#include <stddef.h>
 #include <stdint.h>

 namespace filament::backend {
@@ -18,8 +18,11 @@
 #define TNT_FILAMENT_BACKEND_PRIVATE_OPENGLPLATFORM_H

 #include <backend/AcquiredImage.h>
+#include <backend/DriverEnums.h>
 #include <backend/Platform.h>

+#include <stdint.h>
+
 namespace filament::backend {

 class Driver;
@@ -17,11 +17,10 @@
 #ifndef TNT_FILAMENT_BACKEND_OPENGL_OPENGL_PLATFORM_COCOA_GL_H
 #define TNT_FILAMENT_BACKEND_OPENGL_OPENGL_PLATFORM_COCOA_GL_H

-#include <stdint.h>
-
+#include <backend/DriverEnums.h>
 #include <backend/platforms/OpenGLPlatform.h>

-#include <backend/DriverEnums.h>
+#include <stdint.h>

 namespace filament::backend {

@@ -30,7 +30,7 @@ struct PlatformCocoaTouchGLImpl;
 class PlatformCocoaTouchGL : public OpenGLPlatform {
 public:
    PlatformCocoaTouchGL();
-    ~PlatformCocoaTouchGL() noexcept;
+    ~PlatformCocoaTouchGL() noexcept override;

    // --------------------------------------------------------------------------------------------
    // Platform Interface
@@ -17,18 +17,21 @@
 #ifndef TNT_FILAMENT_BACKEND_OPENGL_OPENGL_PLATFORM_EGL_H
 #define TNT_FILAMENT_BACKEND_OPENGL_OPENGL_PLATFORM_EGL_H

-#include <stdint.h>
+#include <backend/DriverEnums.h>
+#include <backend/Platform.h>
+#include <backend/platforms/OpenGLPlatform.h>

 #include <EGL/egl.h>
 #include <EGL/eglext.h>
+#include <EGL/eglplatform.h>

-#include <backend/platforms/OpenGLPlatform.h>
-
-#include <backend/DriverEnums.h>
-
+#include <initializer_list>
 #include <utility>
 #include <vector>

+#include <stddef.h>
+#include <stdint.h>
+
 namespace filament::backend {

 /**
@@ -17,8 +17,14 @@
 #ifndef TNT_FILAMENT_BACKEND_OPENGL_OPENGL_PLATFORM_EGL_ANDROID_H
 #define TNT_FILAMENT_BACKEND_OPENGL_OPENGL_PLATFORM_EGL_ANDROID_H

+#include <backend/AcquiredImage.h>
+#include <backend/Platform.h>
+#include <backend/platforms/OpenGLPlatform.h>
 #include <backend/platforms/PlatformEGL.h>

+#include <stddef.h>
+#include <stdint.h>
+
 namespace filament::backend {

 class ExternalStreamManagerAndroid;
@@ -20,13 +20,18 @@
 #include <backend/Platform.h>

 #include <bluevk/BlueVK.h>
+
 #include <utils/CString.h>
 #include <utils/FixedCapacityVector.h>
 #include <utils/PrivateImplementation.h>

+#include <string_view>
 #include <tuple>
 #include <unordered_set>

+#include <stddef.h>
+#include <stdint.h>
+
 namespace filament::backend {

 using SwapChain = Platform::SwapChain;
@@ -17,10 +17,7 @@
 #ifndef TNT_FILAMENT_BACKEND_PRIVATE_CIRCULARBUFFER_H
 #define TNT_FILAMENT_BACKEND_PRIVATE_CIRCULARBUFFER_H

-#include <utils/compiler.h>
-
 #include <stddef.h>
-#include <stdint.h>

 namespace filament::backend {

@@ -19,12 +19,14 @@

 #include "private/backend/CircularBuffer.h"

-#include <utils/compiler.h>
 #include <utils/Condition.h>
 #include <utils/Mutex.h>

 #include <vector>

+#include <stddef.h>
+#include <stdint.h>
+
 namespace filament::backend {

 /*
@@ -32,11 +32,13 @@
 #include <backend/TargetBufferInfo.h>

 #include <utils/compiler.h>
+#include <utils/debug.h>
 #include <utils/ThreadUtils.h>

 #include <cstddef>
 #include <functional>
 #include <tuple>
+#include <type_traits>
 #include <utility>

 #ifndef NDEBUG
@@ -152,14 +154,14 @@ struct CommandType<void (Driver::*)(ARGS...)> {
        }

        // placement new declared as "throw" to avoid the compiler's null-check
-        inline void* operator new(std::size_t size, void* ptr) {
+        inline void* operator new(std::size_t, void* ptr) {
            assert_invariant(ptr);
            return ptr;
        }
    };
 };

-// convert an method of "class Driver" into a Command<> type
+// convert a method of "class Driver" into a Command<> type
 #define COMMAND_TYPE(method) CommandType<decltype(&Driver::method)>::Command<&Driver::method>

 // ------------------------------------------------------------------------------------------------
@@ -29,6 +29,7 @@

 #include <functional>

+#include <stddef.h>
 #include <stdint.h>

 // Command debugging off. debugging virtuals are not called.
@@ -22,9 +22,18 @@
 #include <utils/Allocator.h>
 #include <utils/Log.h>
 #include <utils/compiler.h>
+#include <utils/debug.h>
+#include <utils/ostream.h>
+
 #include <tsl/robin_map.h>
+
+#include <exception>
+#include <type_traits>
 #include <unordered_map>

+#include <stddef.h>
+#include <stdint.h>
+
 #if !defined(NDEBUG) && UTILS_HAS_RTTI
 #   define HANDLE_TYPE_SAFETY 1
 #else
@@ -222,7 +231,7 @@ private:
        explicit Allocator(const utils::AreaPolicy::HeapArea& area);

        // this is in fact always called with a constexpr size argument
-        [[nodiscard]] inline void* alloc(size_t size, size_t alignment, size_t extra) noexcept {
+        [[nodiscard]] inline void* alloc(size_t size, size_t, size_t extra) noexcept {
            void* p = nullptr;
                 if (size <= mPool0.getSize()) p = mPool0.alloc(size, 16, extra);
            else if (size <= mPool1.getSize()) p = mPool1.alloc(size, 16, extra);
@@ -19,9 +19,9 @@
 #ifndef TNT_FILAMENT_BACKEND_PLATFORM_FACTORY_H
 #define TNT_FILAMENT_BACKEND_PLATFORM_FACTORY_H

-#include "backend/DriverEnums.h"
+#include <backend/DriverEnums.h>

-#include "utils/compiler.h"
+#include <utils/compiler.h>

 namespace filament::backend {

@@ -17,15 +17,13 @@
 #ifndef TNT_FILAMENT_BACKEND_PRIVATE_SAMPLERGROUP_H
 #define TNT_FILAMENT_BACKEND_PRIVATE_SAMPLERGROUP_H

-#include "backend/DriverApiForward.h"
-
-#include <utils/compiler.h>
-#include <utils/FixedCapacityVector.h>
-
+#include <backend/DriverApiForward.h>
 #include <backend/DriverEnums.h>
-#include <backend/Handle.h>
 #include <backend/SamplerDescriptor.h>

+#include <utils/FixedCapacityVector.h>
+#include <utils/ostream.h>
+
 #include <stddef.h>

 namespace filament::backend {
@@ -19,6 +19,7 @@

 #include <backend/PixelBufferDescriptor.h>

+#include <cstring>
 #include <stddef.h>
 #include <stdint.h>

@@ -21,7 +21,12 @@

 #include <backend/AcquiredImage.h>
 #include <backend/BufferDescriptor.h>
+#include <backend/DriverEnums.h>

+#include <utils/compiler.h>
+#include <utils/debug.h>
+#include <utils/Log.h>
+#include <utils/ostream.h>
 #include <utils/Systrace.h>

 #include <math/half.h>
@@ -29,6 +34,13 @@
 #include <math/vec3.h>
 #include <math/vec4.h>

+#include <functional>
+#include <mutex>
+#include <utility>
+
+#include <stddef.h>
+#include <stdint.h>
+
 using namespace utils;
 using namespace filament::math;

@@ -119,7 +131,8 @@ void DriverBase::purge() noexcept {
 // ------------------------------------------------------------------------------------------------

 void DriverBase::scheduleDestroySlow(BufferDescriptor&& buffer) noexcept {
-    scheduleCallback(buffer.getHandler(), [buffer = std::move(buffer)]() {
+    auto const handler = buffer.getHandler();
+    scheduleCallback(handler, [buffer = std::move(buffer)]() {
        // user callback is called when BufferDescriptor gets destroyed
    });
 }
@@ -20,6 +20,7 @@
 #include "MetalUtils.h"

 #include <utils/Panic.h>
+#include <utils/Log.h>

 namespace filament::backend {

@@ -19,6 +19,7 @@
 #include "MetalContext.h"

 #include <utils/Panic.h>
+#include <utils/Log.h>
 #include <utils/trap.h>

 #include <thread>
@@ -21,6 +21,7 @@
 #include "MetalUtils.h"

 #include <utils/Panic.h>
+#include <utils/Log.h>
 #include <utils/trap.h>

 #define NSERROR_CHECK(message)                                                                     \
@@ -18,6 +18,8 @@

 #include "MetalEnums.h"

+#include <utils/Log.h>
+
 namespace filament {
 namespace backend {

@@ -427,7 +427,6 @@ void OpenGLContext::initBugs(Bugs* bugs, Extensions const& exts,
            if (strstr(renderer, "Mali-T")) {
                bugs->disable_glFlush = true;
                bugs->disable_shared_context_draws = true;
-                bugs->texture_external_needs_rebind = true;
                // We have not verified that timer queries work on Mali-T, so we disable to be safe.
                bugs->dont_use_timer_query = true;
            }
@@ -222,10 +222,6 @@ public:
        // Some drivers have gl state issues when drawing from shared contexts
        bool disable_shared_context_draws;

-        // Some drivers require the GL_TEXTURE_EXTERNAL_OES target to be bound when
-        // the texture image changes, even if it's already bound to that texture
-        bool texture_external_needs_rebind;
-
        // Some web browsers seem to immediately clear the default framebuffer when calling
        // glInvalidateFramebuffer with WebGL 2.0
        bool disable_invalidate_framebuffer;
@@ -433,9 +429,6 @@ private:
            {   bugs.disable_shared_context_draws,
                    "disable_shared_context_draws",
                    ""},
-            {   bugs.texture_external_needs_rebind,
-                    "texture_external_needs_rebind",
-                    ""},
            {   bugs.disable_invalidate_framebuffer,
                    "disable_invalidate_framebuffer",
                    ""},
@@ -711,7 +704,7 @@ void OpenGLContext::bindTexture(GLuint unit, GLuint target, GLuint texId, size_t
    update_state(state.textures.units[unit].targets[targetIndex].texture_id, texId, [&]() {
        activeTexture(unit);
        glBindTexture(target, texId);
-    }, (target == GL_TEXTURE_EXTERNAL_OES) && bugs.texture_external_needs_rebind);
+    }, target == GL_TEXTURE_EXTERNAL_OES);
 }

 void OpenGLContext::bindTexture(GLuint unit, GLuint target, GLuint texId) noexcept {
@@ -147,9 +147,9 @@ Driver* OpenGLDriver::create(OpenGLPlatform* const platform,
 #endif

    size_t const defaultSize = FILAMENT_OPENGL_HANDLE_ARENA_SIZE_IN_MB * 1024U * 1024U;
-    Platform::DriverConfig validConfig {driverConfig};
+    Platform::DriverConfig validConfig{ driverConfig };
    validConfig.handleArenaSize = std::max(driverConfig.handleArenaSize, defaultSize);
-    OpenGLDriver* const driver = new OpenGLDriver(ec, validConfig);
+    OpenGLDriver* const driver = new(std::nothrow) OpenGLDriver(ec, validConfig);
    return driver;
 }

@@ -171,7 +171,8 @@ OpenGLDriver::OpenGLDriver(OpenGLPlatform* platform, const Platform::DriverConfi
          mContext(),
          mShaderCompilerService(*this),
          mHandleAllocator("Handles", driverConfig.handleArenaSize),
-          mSamplerMap(32) {
+          mSamplerMap(32),
+          mDriverConfig(driverConfig) {

    std::fill(mSamplerBindings.begin(), mSamplerBindings.end(), nullptr);

@@ -400,6 +400,9 @@ private:
    // timer query implementation
    OpenGLTimerQueryInterface* mTimerQueryImpl = nullptr;

+    const Platform::DriverConfig mDriverConfig;
+    Platform::DriverConfig const& getDriverConfig() const noexcept { return mDriverConfig; }
+
    // for ES2 sRGB support
    GLSwapChain* mCurrentDrawSwapChain = nullptr;
    bool mRec709OutputColorspace = false;
@@ -151,6 +151,12 @@ bool ShaderCompilerService::isParallelShaderCompileSupported() const noexcept {
 }

 void ShaderCompilerService::init() noexcept {
+    if (UTILS_UNLIKELY(mDriver.getDriverConfig().disableParallelShaderCompile)) {
+        // user disabled parallel shader compile
+        mMode = Mode::SYNCHRONOUS;
+        return;
+    }
+
    // Here we decide which mode we'll be using. We always prefer our own thread-pool if
    // that mode is available because, we have no control on how the compilation queues are
    // handled if done by the driver (so at the very least we'd need to decode this per-driver).
@@ -109,7 +109,7 @@ private:
    };

    enum class Mode {
-        UNDEFINED,      // init() has not beed called yet.
+        UNDEFINED,      // init() has not been called yet.
        SYNCHRONOUS,    // synchronous shader compilation
        THREAD_POOL,    // asynchronous shader compilation using a thread-pool (most common)
        ASYNCHRONOUS    // asynchronous shader compilation using KHR_parallel_shader_compile
@@ -15,6 +15,7 @@
 */

 #include <backend/platforms/VulkanPlatform.h>
+#include <backend/DriverEnums.h>

 #include "vulkan/VulkanConstants.h"
 #include "vulkan/VulkanDriverFactory.h"
@@ -23,6 +24,11 @@

 #include <bluevk/BlueVK.h>

+#include <tuple>
+
+#include <stdint.h>
+#include <stddef.h>
+
 #if defined(__linux__) || defined(__FreeBSD__)
 #define LINUX_OR_FREEBSD 1
 #endif
@@ -21,10 +21,14 @@

 #include <utils/compiler.h>

-#include <limits>
-
+#include <math/mat3.h>
 #include <math/mat4.h>
 #include <math/vec3.h>
+#include <math/vec4.h>
+
+#include <float.h>
+
+#include <stddef.h>

 namespace filament {

@@ -70,7 +74,7 @@ public:
     * @return This bounding box
     */
    Box& set(const math::float3& min, const math::float3& max) noexcept {
-        // float3 ctor needed for visual studio
+        // float3 ctor needed for Visual Studio
        center     = (max + min) * math::float3(0.5f);
        halfExtent = (max - min) * math::float3(0.5f);
        return *this;
@@ -130,17 +134,17 @@ public:
 struct UTILS_PUBLIC Aabb {

    /** min coordinates */
-    math::float3 min = std::numeric_limits<float>::max();
+    math::float3 min = FLT_MAX;

    /** max coordinates */
-    math::float3 max = std::numeric_limits<float>::lowest();
+    math::float3 max = -FLT_MAX;

    /**
     * Computes the center of the box.
     * @return (max + min)/2
     */
    math::float3 center() const noexcept {
-        // float3 ctor needed for visual studio
+        // float3 ctor needed for Visual Studio
        return (max + min) * math::float3(0.5f);
    }

@@ -149,7 +153,7 @@ struct UTILS_PUBLIC Aabb {
     * @return (max - min)/2
     */
    math::float3 extent() const noexcept {
-        // float3 ctor needed for visual studio
+        // float3 ctor needed for Visual Studio
        return (max - min) * math::float3(0.5f);
    }

@@ -198,12 +202,14 @@ struct UTILS_PUBLIC Aabb {
     * @return the maximum signed distance to the box. Negative if p is in the box
     */
    float contains(math::float3 p) const noexcept {
+        // we don't use std::max to avoid a dependency on <algorithm>
+        auto const maximum = [](auto a, auto b) { return a > b ? a : b; };
        float d = min.x - p.x;
-        d = std::max(d, min.y - p.y);
-        d = std::max(d, min.z - p.z);
-        d = std::max(d, p.x - max.x);
-        d = std::max(d, p.y - max.y);
-        d = std::max(d, p.z - max.z);
+        d = maximum(d, min.y - p.y);
+        d = maximum(d, min.z - p.z);
+        d = maximum(d, p.x - max.x);
+        d = maximum(d, p.y - max.y);
+        d = maximum(d, p.z - max.z);
        return d;
    }

@@ -22,11 +22,13 @@
 #include <filament/FilamentAPI.h>

 #include <backend/DriverEnums.h>
-
 #include <backend/BufferDescriptor.h>

 #include <utils/compiler.h>

+#include <stdint.h>
+#include <stddef.h>
+
 namespace filament {

 class FBufferObject;
@@ -28,6 +28,11 @@
 #include <math/vec4.h>
 #include <math/mat4.h>

+#include <math.h>
+
+#include <stdint.h>
+#include <stddef.h>
+
 namespace utils {
 class Entity;
 } // namespace utils
@@ -184,7 +189,7 @@ public:
     * @see Fov.
     */
    static math::mat4 projection(Fov direction, double fovInDegrees,
-            double aspect, double near, double far = std::numeric_limits<double>::infinity());
+            double aspect, double near, double far = INFINITY);

    /** Returns the projection matrix from the focal length.
     *
@@ -194,7 +199,7 @@ public:
     * @param far         distance in world units from the camera to the far plane. \p far > \p near.
     */
    static math::mat4 projection(double focalLengthInMillimeters,
-            double aspect, double near, double far = std::numeric_limits<double>::infinity());
+            double aspect, double near, double far = INFINITY);


    /** Sets the projection matrix from a frustum defined by six planes.
@@ -24,6 +24,9 @@
 #include <math/vec3.h>
 #include <math/vec4.h>

+#include <stdint.h>
+#include <stddef.h>
+
 namespace filament {

 //! RGB color in linear space
@@ -26,6 +26,9 @@

 #include <math/mathfwd.h>

+#include <stdint.h>
+#include <stddef.h>
+
 namespace filament {

 class Engine;
@@ -18,7 +18,6 @@
 #define TNT_FILAMENT_COLOR_SPACE_H

 #include <math/vec2.h>
-#include <math/vec3.h>

 namespace filament::color {

@@ -25,7 +25,7 @@

 #include <math/mathfwd.h>

-#include <stdint.h>
+#include <stddef.h>

 namespace filament {

@@ -19,9 +19,14 @@

 #include <filament/FilamentAPI.h>

+#include <backend/DriverEnums.h>
 #include <backend/Platform.h>

 #include <utils/compiler.h>
+#include <utils/Invocable.h>
+
+#include <stdint.h>
+#include <stddef.h>

 namespace utils {
 class Entity;
@@ -25,6 +25,8 @@

 #include <utils/compiler.h>

+#include <stdint.h>
+
 namespace filament {

 /**
@@ -23,9 +23,12 @@

 #include <math/mat4.h>
 #include <math/vec3.h>
+#include <math/vec4.h>

 #include <utils/unwindows.h> // Because we define NEAR and FAR in the Plane enum.

+#include <stdint.h>
+
 namespace filament {

 class Box;
@@ -27,6 +27,7 @@

 #include <utils/compiler.h>

+#include <stdint.h>
 #include <stddef.h>

 namespace filament {
@@ -25,6 +25,8 @@

 #include <math/mathfwd.h>

+#include <stdint.h>
+
 namespace filament {

 class Engine;
@@ -18,11 +18,14 @@
 #define TNT_FILAMENT_INSTANCEBUFFER_H

 #include <filament/FilamentAPI.h>
-
 #include <filament/Engine.h>

+#include <utils/compiler.h>
+
 #include <math/mathfwd.h>

+#include <stddef.h>
+
 namespace filament {

 /**
@@ -45,7 +48,7 @@ public:
         *                      >= 1 and <= \c Engine::getMaxAutomaticInstances()
         * @see Engine::getMaxAutomaticInstances
         */
-        Builder(size_t instanceCount) noexcept;
+        explicit Builder(size_t instanceCount) noexcept;

        Builder(Builder const& rhs) noexcept;
        Builder(Builder&& rhs) noexcept;
@@ -27,6 +27,9 @@
 #include <math/mathfwd.h>
 #include <math/quat.h>

+#include <stdint.h>
+#include <stddef.h>
+
 namespace utils {
    class Entity;
 } // namespace utils
@@ -30,7 +30,12 @@

 #include <math/mathfwd.h>

+#include <type_traits>
+#include <utility>
+
+#include <stddef.h>
 #include <stdint.h>
+#include <string.h>

 namespace utils {
    class CString;
@@ -28,6 +28,12 @@

 #include <math/mathfwd.h>

+#include <type_traits>
+
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
 namespace filament {

 class Material;
@@ -21,8 +21,11 @@

 #include <filament/Engine.h>

+#include <utils/compiler.h>
+
 #include <math/mathfwd.h>

+#include <stddef.h>

 namespace filament {

@@ -19,10 +19,13 @@

 #include <filament/Color.h>

-#include <stdint.h>
+#include <math/vec2.h>
+#include <math/vec3.h>

 #include <math.h>

+#include <stdint.h>
+
 namespace filament {

 class Texture;
@@ -438,6 +441,7 @@ struct TemporalAntiAliasingOptions {
    float filterWidth = 1.0f;   //!< reconstruction filter width typically between 0.2 (sharper, aliased) and 1.5 (smoother)
    float feedback = 0.12f;     //!< history feedback, between 0 (maximum temporal AA) and 1 (no temporal AA).
    float lodBias = -1.0f;      //!< texturing lod bias (typically -1 or -2)
+    float sharpness = 0.0f;     //!< post-TAA sharpen, especially useful when upscaling is true.
    bool enabled = false;       //!< enables or disables temporal anti-aliasing
    bool upscaling = false;     //!< 4x TAA upscaling. Disables Dynamic Resolution. [BETA]

@@ -457,7 +461,8 @@ struct TemporalAntiAliasingOptions {
        RGSS_X4,             //!  4-samples, rotated grid sampling
        UNIFORM_HELIX_X4,    //!  4-samples, uniform grid in helix sequence
        HALTON_23_X8,        //!  8-samples of halton 2,3
-        HALTON_23_X16        //! 16-samples of halton 2,3
+        HALTON_23_X16,       //! 16-samples of halton 2,3
+        HALTON_23_X32        //! 32-samples of halton 2,3
    };

    bool filterHistory = true;      //!< whether to filter the history buffer
@@ -24,7 +24,10 @@
 #include <backend/DriverEnums.h>
 #include <backend/TargetBufferInfo.h>

+#include <utils/compiler.h>
+
 #include <stddef.h>
+#include <stdint.h>

 namespace filament {

@@ -29,9 +29,15 @@
 #include <utils/FixedCapacityVector.h>

 #include <math/mathfwd.h>
+#include <math/vec3.h>
+#include <math/vec4.h>

 #include <type_traits>

+#include <float.h>
+#include <stddef.h>
+#include <stdint.h>
+
 namespace utils {
    class Entity;
 } // namespace utils
@@ -873,8 +879,8 @@ void RenderableManager::setMorphTargetBufferAt(Instance instance, uint8_t level,
 template<typename VECTOR, typename INDEX, typename, typename>
 Box RenderableManager::computeAABB(VECTOR const* vertices, INDEX const* indices, size_t count,
        size_t stride) noexcept {
-    math::float3 bmin(std::numeric_limits<float>::max());
-    math::float3 bmax(std::numeric_limits<float>::lowest());
+    math::float3 bmin(FLT_MAX);
+    math::float3 bmax(-FLT_MAX);
    for (size_t i = 0; i < count; ++i) {
        VECTOR const* p = reinterpret_cast<VECTOR const*>(
                (char const*)vertices + indices[i] * stride);
@@ -23,9 +23,6 @@

 #include <utils/compiler.h>

-#include <backend/PresentCallable.h>
-#include <backend/DriverEnums.h>
-
 #include <math/vec4.h>

 #include <stdint.h>
@@ -24,6 +24,8 @@
 #include <utils/compiler.h>
 #include <utils/Invocable.h>

+#include <stddef.h>
+
 namespace utils {
    class Entity;
 } // namespace utils
@@ -26,7 +26,7 @@
 #include <math/mathfwd.h>

 #include <stddef.h>
-
+#include <stdint.h>

 namespace filament {

@@ -23,9 +23,10 @@

 #include <utils/compiler.h>

-#include <stdint.h>
 #include <math/mathfwd.h>

+#include <stdint.h>
+
 namespace filament {

 class FSkybox;
@@ -20,12 +20,12 @@
 #include <filament/FilamentAPI.h>

 #include <backend/DriverEnums.h>
-
-#include <backend/PixelBufferDescriptor.h>
 #include <backend/CallbackHandler.h>

 #include <utils/compiler.h>

+#include <stdint.h>
+
 namespace filament {

 class FStream;
@@ -21,11 +21,12 @@

 #include <backend/CallbackHandler.h>
 #include <backend/DriverEnums.h>
-#include <backend/PresentCallable.h>

 #include <utils/compiler.h>
 #include <utils/Invocable.h>

+#include <stdint.h>
+
 namespace filament {

 class Engine;
@@ -20,12 +20,16 @@
 #define TNT_FILAMENT_TEXTURE_H

 #include <filament/FilamentAPI.h>
+
 #include <backend/DriverEnums.h>
 #include <backend/PixelBufferDescriptor.h>

 #include <utils/compiler.h>

+#include <utility>
+
 #include <stddef.h>
+#include <stdint.h>

 namespace filament {

@@ -25,6 +25,8 @@

 #include <math.h>

+#include <stdint.h>
+
 namespace filament {

 /**
@@ -21,6 +21,8 @@

 #include <math/mathfwd.h>

+#include <stdint.h>
+
 namespace filament {

 /**
@@ -26,6 +26,7 @@

 #include <iterator>

+#include <stddef.h>

 namespace utils {
 class Entity;
@@ -27,6 +27,9 @@

 #include <utils/compiler.h>

+#include <stddef.h>
+#include <stdint.h>
+
 namespace filament {

 class FVertexBuffer;
@@ -19,17 +19,19 @@
 #ifndef TNT_FILAMENT_VIEW_H
 #define TNT_FILAMENT_VIEW_H

-#include <filament/Color.h>
 #include <filament/FilamentAPI.h>
 #include <filament/Options.h>

-#include <backend/DriverEnums.h>
-
 #include <utils/compiler.h>
 #include <utils/Entity.h>

 #include <math/mathfwd.h>

+#include <utility>
+
+#include <stddef.h>
+#include <stdint.h>
+
 namespace filament {

 namespace backend {
@@ -23,9 +23,6 @@

 #include <utils/compiler.h>

-#include <math/scalar.h>
-#include <math/mathfwd.h>
-
 #include <stddef.h>
 #include <stdint.h>

@@ -64,6 +64,7 @@
 #include <math/mat3.h>
 #include <math/mat4.h>
 #include <math/scalar.h>
+#include <math/vec2.h>
 #include <math/vec3.h>
 #include <math/vec4.h>

@@ -74,6 +75,7 @@
 #include <utils/FixedCapacityVector.h>

 #include <algorithm>
+#include <array>
 #include <cmath>
 #include <limits>
 #include <string_view>
@@ -113,7 +115,7 @@ PostProcessManager::PostProcessMaterial::PostProcessMaterial() noexcept {
 }

 PostProcessManager::PostProcessMaterial::PostProcessMaterial(MaterialInfo const& info) noexcept
-    : PostProcessMaterial() {
+        : PostProcessMaterial() {
    mData = info.data; // aliased to mMaterial
    mSize = info.size;
    mConstants = info.constants;
@@ -165,7 +167,7 @@ void PostProcessManager::PostProcessMaterial::loadMaterial(FEngine& engine) cons
    mHasMaterial = true;
    auto builder = Material::Builder();
    builder.package(mData, mSize);
-    for (auto const& constant : mConstants) {
+    for (auto const& constant: mConstants) {
        std::visit([&](auto&& arg) {
            builder.constant(constant.name.data(), constant.name.size(), arg);
        }, constant.value);
@@ -187,63 +189,60 @@ PipelineState PostProcessManager::PostProcessMaterial::getPipelineState(
    FMaterial* const material = getMaterial(engine);
    material->prepareProgram(Variant{ variantKey });
    return {
-            .program = material->getProgram(Variant{variantKey}),
+            .program = material->getProgram(Variant{ variantKey }),
            .rasterState = material->getRasterState(),
            .scissor = material->getDefaultInstance()->getScissor()
    };
 }

 UTILS_NOINLINE
-FMaterialInstance* PostProcessManager::PostProcessMaterial::getMaterialInstance(FEngine& engine) const noexcept {
+FMaterialInstance* PostProcessManager::PostProcessMaterial::getMaterialInstance(
+        FEngine& engine) const noexcept {
    FMaterial* const material = getMaterial(engine);
    return material->getDefaultInstance();
 }

 // ------------------------------------------------------------------------------------------------

-const PostProcessManager::JitterSequence<4> PostProcessManager::sRGSS4 = {{
+const PostProcessManager::JitterSequence<4> PostProcessManager::sRGSS4 = {{{
        { 0.625f, 0.125f },
        { 0.125f, 0.375f },
        { 0.875f, 0.625f },
        { 0.375f, 0.875f }
-}};
+}}};

-const PostProcessManager::JitterSequence<4> PostProcessManager::sUniformHelix4 = {{
+const PostProcessManager::JitterSequence<4> PostProcessManager::sUniformHelix4 = {{{
        { 0.25f, 0.25f },
        { 0.75f, 0.75f },
        { 0.25f, 0.75f },
        { 0.75f, 0.25f },
-}};
+}}};

-const PostProcessManager::JitterSequence<16> PostProcessManager::sHaltonSamples = {{
-        { filament::halton( 0, 2), filament::halton( 0, 3) },
-        { filament::halton( 1, 2), filament::halton( 1, 3) },
-        { filament::halton( 2, 2), filament::halton( 2, 3) },
-        { filament::halton( 3, 2), filament::halton( 3, 3) },
-        { filament::halton( 4, 2), filament::halton( 4, 3) },
-        { filament::halton( 5, 2), filament::halton( 5, 3) },
-        { filament::halton( 6, 2), filament::halton( 6, 3) },
-        { filament::halton( 7, 2), filament::halton( 7, 3) },
-        { filament::halton( 8, 2), filament::halton( 8, 3) },
-        { filament::halton( 9, 2), filament::halton( 9, 3) },
-        { filament::halton(10, 2), filament::halton(10, 3) },
-        { filament::halton(11, 2), filament::halton(11, 3) },
-        { filament::halton(12, 2), filament::halton(12, 3) },
-        { filament::halton(13, 2), filament::halton(13, 3) },
-        { filament::halton(14, 2), filament::halton(14, 3) },
-        { filament::halton(15, 2), filament::halton(15, 3) }
-}};
+template<size_t COUNT>
+constexpr auto halton() {
+    std::array<float2, COUNT> h;
+    for (size_t i = 0; i < COUNT; i++) {
+        h[i] = {
+                filament::halton(i, 2),
+                filament::halton(i, 3) };
+    }
+    return h;
+}
+
+const PostProcessManager::JitterSequence<32>
+        PostProcessManager::sHaltonSamples = { halton<32>() };

 PostProcessManager::PostProcessManager(FEngine& engine) noexcept
        : mEngine(engine),
-         mWorkaroundSplitEasu(false),
-         mWorkaroundAllowReadOnlyAncillaryFeedbackLoop(false) {
+          mWorkaroundSplitEasu(false),
+          mWorkaroundAllowReadOnlyAncillaryFeedbackLoop(false) {
 }

 PostProcessManager::~PostProcessManager() noexcept = default;

 UTILS_NOINLINE
-void PostProcessManager::registerPostProcessMaterial(std::string_view name, MaterialInfo const& info) {
+void PostProcessManager::registerPostProcessMaterial(std::string_view name,
+        MaterialInfo const& info) {
    mMaterialRegistry.try_emplace(name, info);
 }

@@ -308,6 +307,7 @@ static const PostProcessManager::MaterialInfo sMaterialList[] = {
        { "fsr_rcas",                   MATERIAL(FSR_RCAS) },
        { "debugShadowCascades",        MATERIAL(DEBUGSHADOWCASCADES) },
        { "resolveDepth",               MATERIAL(RESOLVEDEPTH) },
+        { "shadowmap",                  MATERIAL(SHADOWMAP) },
 };

 void PostProcessManager::init() noexcept {
@@ -326,13 +326,13 @@ void PostProcessManager::init() noexcept {
            driver.isWorkaroundNeeded(Workaround::ALLOW_READ_ONLY_ANCILLARY_FEEDBACK_LOOP);

    #pragma nounroll
-    for (auto const& info : sMaterialListFeatureLevel0) {
+    for (auto const& info: sMaterialListFeatureLevel0) {
        registerPostProcessMaterial(info.name, info);
    }

    if (mEngine.getActiveFeatureLevel() >= FeatureLevel::FEATURE_LEVEL_1) {
        #pragma nounroll
-        for (auto const& info : sMaterialList) {
+        for (auto const& info: sMaterialList) {
            registerPostProcessMaterial(info.name, info);
        }
    }
@@ -1683,8 +1683,8 @@ FrameGraphId<FrameGraphTexture> PostProcessManager::dof(FrameGraph& fg,

    // we assume the width/height is already multiple of 16
    assert_invariant(!(colorDesc.width  & 0xF) && !(colorDesc.height & 0xF));
-    const uint32_t tileBufferWidth  = colorDesc.width  / dofResolution;
-    const uint32_t tileBufferHeight = colorDesc.height / dofResolution;
+    const uint32_t tileBufferWidth  = width;
+    const uint32_t tileBufferHeight = height;
    const size_t tileReductionCount = ctz(tileSize / dofResolution);

    struct PostProcessDofTiling1 {
@@ -2569,6 +2569,8 @@ void PostProcessManager::prepareTaa(FrameGraph& fg,
            case JitterPattern::HALTON_23_X8:
                return sHaltonSamples(frameIndex % 8);
            case JitterPattern::HALTON_23_X16:
+                return sHaltonSamples(frameIndex % 16);
+            case JitterPattern::HALTON_23_X32:
                return sHaltonSamples(frameIndex);
        }
    };
@@ -2618,6 +2620,7 @@ void PostProcessManager::configureTemporalAntiAliasingMaterial(
        }
    };

+    setConstantParameter(ma, "upscaling", taaOptions.upscaling);
    setConstantParameter(ma, "historyReprojection", taaOptions.historyReprojection);
    setConstantParameter(ma, "filterHistory", taaOptions.filterHistory);
    setConstantParameter(ma, "filterInput", taaOptions.filterInput);
@@ -2767,24 +2770,77 @@ FrameGraphId<FrameGraphTexture> PostProcessManager::taa(FrameGraph& fg,
            });

    input = colorGradingConfig.asSubpass ? taaPass->tonemappedOutput : taaPass->output;
+    auto history = input;
+
+    // optional sharpen pass from FSR1
+    if (taaOptions.sharpness > 0.0f) {
+        input = rcas(fg, taaOptions.sharpness,
+                input, fg.getDescriptor(input), colorGradingConfig.translucent);
+    }

    struct ExportColorHistoryData {
        FrameGraphId<FrameGraphTexture> color;
    };
-    auto& exportHistoryPass = fg.addPass<ExportColorHistoryData>("Export TAA history",
+    fg.addPass<ExportColorHistoryData>("Export TAA history",
            [&](FrameGraph::Builder& builder, auto& data) {
                // We need to use sideEffect here to ensure this pass won't be culled.
                // The "output" of this pass is going to be used during the next frame as
                // an "import".
                builder.sideEffect();
-                data.color = builder.sample(input); // FIXME: an access must be declared for detach(), why?
-            }, [&current](FrameGraphResources const& resources, auto const& data,
-                    backend::DriverApi&) {
-                resources.detach(data.color,
-                        &current.color, &current.desc);
+                data.color = builder.sample(history); // FIXME: an access must be declared for detach(), why?
+            }, [&current](FrameGraphResources const& resources, auto const& data, auto&) {
+                resources.detach(data.color, &current.color, &current.desc);
            });

-    return exportHistoryPass->color;
+    return input;
+}
+
+FrameGraphId<FrameGraphTexture> PostProcessManager::rcas(
+        FrameGraph& fg,
+        float sharpness,
+        FrameGraphId<FrameGraphTexture> input,
+        FrameGraphTexture::Descriptor const& outDesc,
+        bool translucent) {
+
+    struct QuadBlitData {
+        FrameGraphId<FrameGraphTexture> input;
+        FrameGraphId<FrameGraphTexture> output;
+    };
+
+    auto& ppFsrRcas = fg.addPass<QuadBlitData>("FidelityFX FSR1 Rcas",
+            [&](FrameGraph::Builder& builder, auto& data) {
+                data.input = builder.sample(input);
+                data.output = builder.createTexture("FFX FSR1 Rcas output", outDesc);
+                data.output = builder.declareRenderPass(data.output);
+            },
+            [=](FrameGraphResources const& resources,
+                    auto const& data, DriverApi& driver) {
+
+                auto input = resources.getTexture(data.input);
+                auto out = resources.getRenderPassInfo();
+                auto const& outputDesc = resources.getDescriptor(data.input);
+
+                auto& material = getPostProcessMaterial("fsr_rcas");
+                FMaterialInstance* const mi = material.getMaterialInstance(mEngine);
+
+                FSRUniforms uniforms;
+                FSR_SharpeningSetup(&uniforms, { .sharpness = 2.0f - 2.0f * sharpness });
+                mi->setParameter("RcasCon", uniforms.RcasCon);
+                mi->setParameter("color", input, {}); // uses texelFetch
+                mi->setParameter("resolution", float4{
+                        outputDesc.width, outputDesc.height,
+                        1.0f / outputDesc.width, 1.0f / outputDesc.height });
+                mi->commit(driver);
+                mi->use(driver);
+
+                const uint8_t variant = uint8_t(
+                        translucent ? PostProcessVariant::TRANSLUCENT : PostProcessVariant::OPAQUE);
+
+                PipelineState const pipeline(material.getPipelineState(mEngine, variant));
+                render(out, pipeline, driver);
+            });
+
+    return ppFsrRcas->output;
 }

 FrameGraphId<FrameGraphTexture> PostProcessManager::upscale(FrameGraph& fg, bool translucent,
@@ -2947,41 +3003,9 @@ FrameGraphId<FrameGraphTexture> PostProcessManager::upscale(FrameGraph& fg, bool
    auto output = ppQuadBlit->output;

    // if we had to take the low quality fallback, we still do the "sharpen pass"
-    if (dsrOptions.sharpness > 0.0f && (dsrOptions.quality != QualityLevel::LOW || lowQualityFallback)) {
-        auto& ppFsrRcas = fg.addPass<QuadBlitData>("FidelityFX FSR1 Rcas",
-                [&](FrameGraph::Builder& builder, auto& data) {
-                    data.input = builder.sample(output);
-                    data.output = builder.createTexture("FFX FSR1 Rcas output", outDesc);
-                    data.output = builder.declareRenderPass(data.output);
-                },
-                [=](FrameGraphResources const& resources,
-                        auto const& data, DriverApi& driver) {
-
-                    auto color = resources.getTexture(data.input);
-                    auto out = resources.getRenderPassInfo();
-                    auto const& outputDesc = resources.getDescriptor(data.output);
-
-                    auto& material = getPostProcessMaterial("fsr_rcas");
-                    FMaterialInstance* const mi = material.getMaterialInstance(mEngine);
-
-                    FSRUniforms uniforms;
-                    FSR_SharpeningSetup(&uniforms, { .sharpness = 2.0f - 2.0f * dsrOptions.sharpness });
-                    mi->setParameter("RcasCon", uniforms.RcasCon);
-                    mi->setParameter("color", color, { }); // uses texelFetch
-                    mi->setParameter("resolution", float4{
-                            outputDesc.width, outputDesc.height,
-                            1.0f / outputDesc.width, 1.0f / outputDesc.height });
-                    mi->commit(driver);
-                    mi->use(driver);
-
-                    const uint8_t variant = uint8_t(translucent ?
-                            PostProcessVariant::TRANSLUCENT : PostProcessVariant::OPAQUE);
-
-                    PipelineState const pipeline(material.getPipelineState(mEngine, variant));
-                    render(out, pipeline, driver);
-                });
-
-        output = ppFsrRcas->output;
+    if (dsrOptions.sharpness > 0.0f &&
+            (dsrOptions.quality != QualityLevel::LOW || lowQualityFallback)) {
+        output = rcas(fg, dsrOptions.sharpness, output, outDesc, translucent);
    }

    // we rely on automatic culling of unused render passes
@@ -3250,4 +3274,51 @@ FrameGraphId<FrameGraphTexture> PostProcessManager::debugShadowCascades(FrameGra
    return debugShadowCascadePass->output;
 }

+FrameGraphId<FrameGraphTexture> PostProcessManager::debugDisplayShadowTexture(
+        FrameGraph& fg,
+        FrameGraphId<FrameGraphTexture> input,
+        FrameGraphId<FrameGraphTexture> shadowmap, float scale,
+        uint8_t layer, uint8_t level, uint8_t channel, float power) noexcept {
+    if (shadowmap) {
+        struct ShadowMapData {
+            FrameGraphId<FrameGraphTexture> color;
+            FrameGraphId<FrameGraphTexture> depth;
+        };
+
+        auto const& desc = fg.getDescriptor(input);
+        float const ratio = float(desc.height) / float(desc.width);
+        float const screenScale = float(fg.getDescriptor(shadowmap).height) / float(desc.height);
+        float2 const s = { screenScale * scale * ratio, screenScale * scale };
+
+        auto& shadomapDebugPass = fg.addPass<ShadowMapData>("shadowmap debug pass",
+                [&](FrameGraph::Builder& builder, auto& data) {
+                    data.color = builder.read(input,
+                            FrameGraphTexture::Usage::COLOR_ATTACHMENT);
+                    data.color = builder.write(data.color,
+                            FrameGraphTexture::Usage::COLOR_ATTACHMENT);
+                    data.depth = builder.sample(shadowmap);
+                    builder.declareRenderPass("color target", {
+                            .attachments = { .color = { data.color }}
+                    });
+                },
+                [=](FrameGraphResources const& resources, auto const& data, DriverApi& driver) {
+                    auto out = resources.getRenderPassInfo();
+                    auto in = resources.getTexture(data.depth);
+                    auto const& material = getPostProcessMaterial("shadowmap");
+                    FMaterialInstance* const mi = material.getMaterialInstance(mEngine);
+                    mi->setParameter("shadowmap", in, {
+                        .filterMin = SamplerMinFilter::NEAREST_MIPMAP_NEAREST });
+                    mi->setParameter("scale", s);
+                    mi->setParameter("layer", (uint32_t)layer);
+                    mi->setParameter("level", (uint32_t)level);
+                    mi->setParameter("channel", (uint32_t)channel);
+                    mi->setParameter("power", power);
+                    commitAndRender(out, material, driver);
+                });
+        input = shadomapDebugPass->color;
+    }
+    return input;
+}
+
+
 } // namespace filament
@@ -36,6 +36,7 @@

 #include <tsl/robin_map.h>

+#include <array>
 #include <random>
 #include <string_view>
 #include <variant>
@@ -241,6 +242,13 @@ public:
            filament::Viewport const& vp, FrameGraphTexture::Descriptor const& outDesc,
            backend::SamplerMagFilter filter) noexcept;

+    FrameGraphId<FrameGraphTexture> rcas(
+            FrameGraph& fg,
+            float sharpness,
+            FrameGraphId<FrameGraphTexture> input,
+            FrameGraphTexture::Descriptor const& outDesc,
+            bool translucent);
+
    // upscale/downscale blitter using shaders
    FrameGraphId<FrameGraphTexture> blit(FrameGraph& fg, bool translucent,
            FrameGraphId<FrameGraphTexture> input,
@@ -274,6 +282,11 @@ public:
            FrameGraphId<FrameGraphTexture> input,
            FrameGraphId<FrameGraphTexture> depth) noexcept;

+    FrameGraphId<FrameGraphTexture> debugDisplayShadowTexture(FrameGraph& fg,
+            FrameGraphId<FrameGraphTexture> input,
+            FrameGraphId<FrameGraphTexture> shadowmap, float scale,
+            uint8_t layer, uint8_t level, uint8_t channel, float power) noexcept;
+
    backend::Handle<backend::HwTexture> getOneTexture() const;
    backend::Handle<backend::HwTexture> getZeroTexture() const;
    backend::Handle<backend::HwTexture> getOneTextureArray() const;
@@ -362,12 +375,12 @@ private:
    template<size_t SIZE>
    struct JitterSequence {
        auto operator()(size_t i) const noexcept { return positions[i % SIZE] - 0.5f; }
-        const math::float2 positions[SIZE];
+        const std::array<math::float2, SIZE> positions;
    };

    static const JitterSequence<4> sRGSS4;
    static const JitterSequence<4> sUniformHelix4;
-    static const JitterSequence<16> sHaltonSamples;
+    static const JitterSequence<32> sHaltonSamples;

    bool mWorkaroundSplitEasu : 1;
    bool mWorkaroundAllowReadOnlyAncillaryFeedbackLoop : 1;
@@ -294,6 +294,8 @@ FrameGraphId<FrameGraphTexture> ShadowMapManager::render(FEngine& engine, FrameG
    // Shadow Passes
    // -------------------------------------------------------------------------------------------

+    fg.getBlackboard()["shadowmap"] = prepareShadowPass->shadows;
+
    struct ShadowPassData {
        FrameGraphId<FrameGraphTexture> tempBlurSrc{};  // temporary shadowmap when blurring
        FrameGraphId<FrameGraphTexture> output;
@@ -943,6 +945,10 @@ void ShadowMapManager::calculateTextureRequirements(FEngine& engine, FView& view
        mipLevels = std::max(1, FTexture::maxLevelCount(maxDimension) - lowMipmapLevel);
    }

+    // publish the debugging data
+    engine.debug.shadowmap.display_shadow_texture_layer_count = layersNeeded;
+    engine.debug.shadowmap.display_shadow_texture_level_count = mipLevels;
+
    mTextureAtlasRequirements = {
            (uint16_t)maxDimension,
            layersNeeded,
@@ -30,11 +30,12 @@
 #include <math/vec4.h>

 #include <utils/JobSystem.h>
-#include <utils/SpinLock.h>
+#include <utils/Mutex.h>
 #include <utils/Systrace.h>

 #include <cmath>
 #include <cstdlib>
+#include <mutex>
 #include <tuple>

 namespace filament {
@@ -648,9 +649,9 @@ FColorGrading::FColorGrading(FEngine& engine, const Builder& builder) {
    Config c;
    // This lock protects the data inside Config, which is written to by the Filament thread,
    // and read from multiple Job threads.
-    utils::SpinLock configLock;
+    utils::Mutex configLock;
    {
-        std::lock_guard<utils::SpinLock> lock(configLock);
+        std::lock_guard<utils::Mutex> const lock(configLock);
        c.lutDimension          = builder->dimension;
        c.adaptationTransform   = adaptationTransform(builder->whiteBalance);
        c.colorGradingIn        = selectColorGradingTransformIn(builder->toneMapping);
@@ -687,7 +688,7 @@ FColorGrading::FColorGrading(FEngine& engine, const Builder& builder) {
                [data, converted, b, &c, &configLock, builder](JobSystem&, JobSystem::Job*) {
            Config config;
            {
-                std::lock_guard<utils::SpinLock> lock(configLock);
+                std::lock_guard<utils::Mutex> lock(configLock);
                config = c;
            }
            half4* UTILS_RESTRICT p = (half4*) data + b * config.lutDimension * config.lutDimension;
@@ -548,12 +548,20 @@ public:
    struct {
        struct {
            bool debug_directional_shadowmap = false;
+            bool display_shadow_texture = false;
            bool far_uses_shadowcasters = true;
            bool focus_shadowcasters = true;
            bool visualize_cascades = false;
            bool tightly_bound_scene = true;
            float dzn = -1.0f;
            float dzf =  1.0f;
+            float display_shadow_texture_scale = 0.25f;
+            int display_shadow_texture_layer = 0;
+            int display_shadow_texture_level = 0;
+            int display_shadow_texture_channel = 0;
+            int display_shadow_texture_layer_count = 0;
+            int display_shadow_texture_level_count = 0;
+            float display_shadow_texture_power = 1;
        } shadowmap;
        struct {
            bool camera_at_origin = true;
@@ -33,6 +33,7 @@
 #include <utils/Mutex.h>

 #include <atomic>
+#include <optional>

 namespace filament {

@@ -70,6 +70,22 @@ FRenderer::FRenderer(FEngine& engine) :
            &engine.debug.renderer.doFrameCapture);
    debugRegistry.registerProperty("d.renderer.disable_buffer_padding",
            &engine.debug.renderer.disable_buffer_padding);
+    debugRegistry.registerProperty("d.shadowmap.display_shadow_texture",
+            &engine.debug.shadowmap.display_shadow_texture);
+    debugRegistry.registerProperty("d.shadowmap.display_shadow_texture_scale",
+            &engine.debug.shadowmap.display_shadow_texture_scale);
+    debugRegistry.registerProperty("d.shadowmap.display_shadow_texture_layer",
+            &engine.debug.shadowmap.display_shadow_texture_layer);
+    debugRegistry.registerProperty("d.shadowmap.display_shadow_texture_level",
+            &engine.debug.shadowmap.display_shadow_texture_level);
+    debugRegistry.registerProperty("d.shadowmap.display_shadow_texture_channel",
+            &engine.debug.shadowmap.display_shadow_texture_channel);
+    debugRegistry.registerProperty("d.shadowmap.display_shadow_texture_layer_count",
+            &engine.debug.shadowmap.display_shadow_texture_layer_count);
+    debugRegistry.registerProperty("d.shadowmap.display_shadow_texture_level_count",
+            &engine.debug.shadowmap.display_shadow_texture_level_count);
+    debugRegistry.registerProperty("d.shadowmap.display_shadow_texture_power",
+            &engine.debug.shadowmap.display_shadow_texture_power);

    DriverApi& driver = engine.getDriverApi();

@@ -985,8 +1001,7 @@ void FRenderer::renderJob(ArenaScope& arena, FView& view) {
                    auto& history = view.getFrameHistory();
                    auto& current = history.getCurrent();
                    current.ssr.projection = projection;
-                    resources.detach(data.history,
-                            &current.ssr.color, &current.ssr.desc);
+                    resources.detach(data.history, &current.ssr.color, &current.ssr.desc);
                });
    }

@@ -1134,6 +1149,16 @@ void FRenderer::renderJob(ArenaScope& arena, FView& view) {
                "SwapChain::CONFIG_HAS_STENCIL_BUFFER flag set.");
    }

+    if (UTILS_UNLIKELY(engine.debug.shadowmap.display_shadow_texture)) {
+        auto shadowmap = blackboard.get<FrameGraphTexture>("shadowmap");
+        input = ppm.debugDisplayShadowTexture(fg, input, shadowmap,
+                engine.debug.shadowmap.display_shadow_texture_scale,
+                engine.debug.shadowmap.display_shadow_texture_layer,
+                engine.debug.shadowmap.display_shadow_texture_level,
+                engine.debug.shadowmap.display_shadow_texture_channel,
+                engine.debug.shadowmap.display_shadow_texture_power);
+    }
+
 //    auto debug = structure
 //    fg.forwardResource(fgViewRenderTarget, debug ? debug : input);

@@ -132,7 +132,7 @@ public:
    Descriptor descriptor;
    SubResourceDescriptor subResourceDescriptor;

-    // weather the resource was detached
+    // whether the resource was detached
    bool detached = false;

    // An Edge with added data from this resource
@@ -34,6 +34,11 @@ material {
        }
    ],
    constants : [
+        {
+            type : bool,
+            name : upscaling,
+            default : false
+        },
        {
            type : bool,
            name : historyReprojection,
@@ -109,12 +114,41 @@ fragment {
 // no clipping (for debugging only)
 #define BOX_CLIPPING_NONE       2

-float luma(const vec3 color) {
-    if (materialConstants_useYCoCg) {
-        return color.x;
-    } else {
-        return luminance(color);
-    }
+float rcp(float x) {
+    return 1.0 / x;
+}
+
+float lumaRGB(const vec3 c) {
+    return luminance(c);
+}
+
+float lumaYCoCg(const vec3 c) {
+    return c.x;
+}
+
+float luma(const vec3 c) {
+    return materialConstants_useYCoCg ? lumaYCoCg(c) : lumaRGB(c);
+}
+
+vec3 tonemap(const vec3 c) {
+    return c * rcp(1.0 + max3(c));
+}
+
+vec4 tonemap(const vec4 c) {
+    return vec4(c.rgb * rcp(1.0 + max3(c.rgb)), c.a);
+}
+
+vec3 tonemap(const float w, const vec3 c) {
+    return c * (w * rcp(1.0 + max3(c)));
+}
+
+vec4 tonemap(const float w, const vec4 c) {
+    return vec4(c.rgb * (w * rcp(1.0 + max3(c.rgb))), c.a);
+}
+
+vec3 untonemap(const vec3 c) {
+    const float epsilon = 1.0 / 65504.0;
+    return c * rcp(max(epsilon, 1.0 - max3(c)));
 }

 vec3 RGB_YCoCg(const vec3 c) {
@@ -159,15 +193,16 @@ vec4 clipToBox(const int quality,
 // Optimized to 5 taps by removing the corner samples
 // And modified for mediump support
 vec4 sampleTextureCatmullRom(const sampler2D tex, const highp vec2 uv, const highp vec2 texSize) {
-    // We're going to sample a a 4x4 grid of texels surrounding the target UV coordinate. We'll do this by rounding
-    // down the sample location to get the exact center of our "starting" texel. The starting texel will be at
-    // location [1, 1] in the grid, where [0, 0] is the top left corner.
+    // We're going to sample a a 4x4 grid of texels surrounding the target UV coordinate.
+    // We'll do this by rounding down the sample location to get the exact center of our "starting"
+    // texel. The starting texel will be at location [1, 1] in the grid, where [0, 0] is the
+    // top left corner.

    highp vec2 samplePos = uv * texSize;
    highp vec2 texPos1 = floor(samplePos - 0.5) + 0.5;

-    // Compute the fractional offset from our starting texel to our original sample location, which we'll
-    // feed into the Catmull-Rom spline function to get our filter weights.
+    // Compute the fractional offset from our starting texel to our original sample location,
+    // which we'll feed into the Catmull-Rom spline function to get our filter weights.
    highp vec2 f = samplePos - texPos1;
    highp vec2 f2 = f * f;
    highp vec2 f3 = f2 * f;
@@ -200,13 +235,20 @@ vec4 sampleTextureCatmullRom(const sampler2D tex, const highp vec2 uv, const hig
    float k3 = w3.x  * w12.y;
    float k4 = w12.x * w3.y;

-    vec4 result =   textureLod(tex, vec2(texPos12.x, texPos0.y),  0.0) * k0
-                  + textureLod(tex, vec2(texPos0.x,  texPos12.y), 0.0) * k1
-                  + textureLod(tex, vec2(texPos12.x, texPos12.y), 0.0) * k2
-                  + textureLod(tex, vec2(texPos3.x,  texPos12.y), 0.0) * k3
-                  + textureLod(tex, vec2(texPos12.x, texPos3.y),  0.0) * k4;
+    vec4 s[5];
+    s[0] = textureLod(tex, vec2(texPos12.x, texPos0.y),  0.0);
+    s[1] = textureLod(tex, vec2(texPos0.x,  texPos12.y), 0.0);
+    s[2] = textureLod(tex, vec2(texPos12.x, texPos12.y), 0.0);
+    s[3] = textureLod(tex, vec2(texPos3.x,  texPos12.y), 0.0);
+    s[4] = textureLod(tex, vec2(texPos12.x, texPos3.y),  0.0);

-    result *= 1.0 / (k0 + k1 + k2 + k3 + k4);
+    vec4 result =   k0 * s[0]
+                  + k1 * s[1]
+                  + k2 * s[2]
+                  + k3 * s[3]
+                  + k4 * s[4];
+
+    result *= rcp(k0 + k1 + k2 + k3 + k4);

    // we could end-up with negative values
    result = max(vec4(0), result);
@@ -242,7 +284,7 @@ void postProcess(inout PostProcessInputs postProcess) {

    highp vec2 size = vec2(textureSize(materialParams_color, 0));
    highp vec2 p = (floor(uv.xy * size) + 0.5) / size;
-    vec4 color = textureLod(materialParams_color, p, 0.0);
+    vec4 filtered = textureLod(materialParams_color, p, 0.0);

    vec3 s[9];
    if (materialConstants_filterInput || materialConstants_boxClipping != BOX_CLIPPING_NONE) {
@@ -250,16 +292,12 @@ void postProcess(inout PostProcessInputs postProcess) {
        s[1] = textureLodOffset(materialParams_color, p, 0.0, ivec2( 0, -1)).rgb;
        s[2] = textureLodOffset(materialParams_color, p, 0.0, ivec2( 1, -1)).rgb;
        s[3] = textureLodOffset(materialParams_color, p, 0.0, ivec2(-1,  0)).rgb;
-        s[4] = color.rgb;
+        s[4] = filtered.rgb;
        s[5] = textureLodOffset(materialParams_color, p, 0.0, ivec2( 1,  0)).rgb;
        s[6] = textureLodOffset(materialParams_color, p, 0.0, ivec2(-1,  1)).rgb;
        s[7] = textureLodOffset(materialParams_color, p, 0.0, ivec2( 0,  1)).rgb;
        s[8] = textureLodOffset(materialParams_color, p, 0.0, ivec2( 1,  1)).rgb;
-    }
-
-    if (materialConstants_useYCoCg) {
-        color.rgb = RGB_YCoCg(color.rgb);
-        if (materialConstants_filterInput || materialConstants_boxClipping != BOX_CLIPPING_NONE) {
+        if (materialConstants_useYCoCg) {
            for (int i = 0; i < 9; i++) {
                s[i] = RGB_YCoCg(s[i]);
            }
@@ -267,24 +305,35 @@ void postProcess(inout PostProcessInputs postProcess) {
    }

    vec2 subPixelOffset = p - uv.xy;  // +/- [0.25, 0.25]
-    float confidence = 0.0;
+    float confidence = materialConstants_upscaling ? 0.0 : 1.0;

-    vec4 filtered = color;
    if (materialConstants_filterInput) {
        // unjitter/filter input
        // figure out which set of coeficients to use
-        int jxp = subPixelOffset.y > 0.0 ? 3 : 0;
-        int jxn = subPixelOffset.y > 0.0 ? 2 : 1;
-        int j   = subPixelOffset.x > 0.0 ? jxp : jxn;
-        filtered = vec4(0, 0, 0, color.a);
-        for (int i = 0; i < 9; i++) {
-            float w = materialParams.filterWeights[i][j];
-            filtered.rgb += s[i] * w;
-            confidence = max(confidence, w);
+        filtered = vec4(0, 0, 0, filtered.a);
+        if (materialConstants_upscaling) {
+            int jxp = subPixelOffset.y > 0.0 ? 3 : 0;
+            int jxn = subPixelOffset.y > 0.0 ? 2 : 1;
+            int j   = subPixelOffset.x > 0.0 ? jxp : jxn;
+            for (int i = 0; i < 9; i++) {
+                float w = materialParams.filterWeights[i][j];
+                filtered.rgb += s[i] * w;
+                confidence = max(confidence, w);
+            }
+        } else {
+            for (int i = 0; i < 9; i++) {
+                float w = materialParams.filterWeights[i][0];
+                filtered.rgb += s[i] * w;
+            }
        }
    } else {
-        confidence = float(materialParams.jitter.x * subPixelOffset.x > 0.0 &&
-                           materialParams.jitter.y * subPixelOffset.y > 0.0);
+        if (materialConstants_useYCoCg) {
+            filtered.rgb = RGB_YCoCg(filtered.rgb);
+        }
+        if (materialConstants_upscaling) {
+            confidence = float(materialParams.jitter.x * subPixelOffset.x > 0.0 &&
+                               materialParams.jitter.y * subPixelOffset.y > 0.0);
+        }
    }

    // build the history clamping box
@@ -329,29 +378,30 @@ void postProcess(inout PostProcessInputs postProcess) {
        history = clipToBox(materialConstants_boxClipping, boxmin, boxmax, filtered, history);
    }

-    float lumaColor   = luma(filtered.rgb);
-    float lumaHistory = luma(history.rgb);
-
    float alpha = materialParams.alpha * confidence;
    if (materialConstants_preventFlickering) {
        // [Lottes] prevents flickering by modulating the blend weight by the difference in luma
+        float lumaColor = luma(filtered.rgb);
+        float lumaHistory = luma(history.rgb);
        float diff = 1.0 - abs(lumaColor - lumaHistory) / (0.001 + max(lumaColor, lumaHistory));
        alpha *= diff * diff;
    }

-    // tonemapping for handling HDR
-    filtered.rgb *= 1.0 / (1.0 + lumaColor);
-    history.rgb  *= 1.0 / (1.0 + lumaHistory);
+    // go back to RGB space before tonemapping
+    if (materialConstants_useYCoCg) {
+        filtered.rgb = YCoCg_RGB(filtered.rgb);
+        history.rgb = YCoCg_RGB(history.rgb);
+    }
+
+    // tonemap before mixing
+    filtered.rgb = tonemap(filtered.rgb);
+    history.rgb = tonemap(history.rgb);

    // combine history and current frame
    vec4 result = mix(history, filtered, alpha);

    // untonemap result
-    result.rgb *= 1.0 / (1.0 - luma(result.rgb));
-
-    if (materialConstants_useYCoCg) {
-        result.rgb = YCoCg_RGB(result.rgb);
-    }
+    result.rgb = untonemap(result.rgb);

 #if POST_PROCESS_OPAQUE
    // kill the work performed above
@@ -43,6 +43,8 @@ fragment {
    #define FSR_RCAS_F 1
    #if !POST_PROCESS_OPAQUE
    #   define FSR_RCAS_PASSTHROUGH_ALPHA
+    // todo: make this a spec constant
+    #   define FSR_RCAS_DENOISE
    #endif
    #include "ffx_fsr1.h"

@@ -61,6 +63,9 @@ fragment {
 #endif
            p, materialParams.RcasCon);

+        // todo: make this an option
+        postProcess.color.rgb = max(vec3(0), postProcess.color.rgb);
+
 #if POST_PROCESS_OPAQUE
        postProcess.color.a = 1.0;
 #endif
@@ -0,0 +1,59 @@
+material {
+    name : shadowmap,
+    parameters : [
+        {
+           type : sampler2dArray,
+           name : shadowmap,
+           precision : high
+        },
+        {
+           type : float,
+           name : power,
+           precision : high
+        },
+        {
+           type : float2,
+           name : scale,
+        },
+        {
+            type : int,
+            name : layer
+        },
+        {
+            type : int,
+            name : level
+        },
+        {
+            type : int,
+            name : channel
+        }
+    ],
+    variables : [
+        vertex
+    ],
+    vertexDomain : device,
+    depthWrite : false,
+    depthCulling : false,
+    domain: postprocess
+}
+
+vertex {
+    void postProcessVertex(inout PostProcessVertexInputs postProcess) {
+        postProcess.vertex.xy = postProcess.normalizedUV;
+        postProcess.position.xy = 1.0 + (postProcess.position.xy - 1.0) * materialParams.scale;
+    }
+}
+
+fragment {
+    void dummy(){}
+
+    void postProcess(inout PostProcessInputs postProcess) {
+        highp vec2 uv = uvToRenderTargetUV(variable_vertex.xy);
+        highp vec3 p = vec3(uv, float(materialParams.layer));
+        float m = float(materialParams.level);
+        highp float c = textureLod(materialParams_shadowmap, p, m)[materialParams.channel];
+        c = pow(abs(c), materialParams.power);
+        postProcess.color.rgb = vec3(c);
+        postProcess.color.a = 1.0;
+    }
+}
@@ -1,12 +1,12 @@
 Pod::Spec.new do |spec|
  spec.name = "Filament"
-  spec.version = "1.49.3"
+  spec.version = "1.50.0"
  spec.license = { :type => "Apache 2.0", :file => "LICENSE" }
  spec.homepage = "https://google.github.io/filament"
  spec.authors = "Google LLC."
  spec.summary = "Filament is a real-time physically based rendering engine for Android, iOS, Windows, Linux, macOS, and WASM/WebGL."
  spec.platform = :ios, "11.0"
-  spec.source = { :http => "https://github.com/google/filament/releases/download/v1.49.3/filament-v1.49.3-ios.tgz" }
+  spec.source = { :http => "https://github.com/google/filament/releases/download/v1.50.0/filament-v1.50.0-ios.tgz" }

  # Fix linking error with Xcode 12; we do not yet support the simulator on Apple silicon.
  spec.pod_target_xcconfig = {
@@ -0,0 +1,108 @@
+cmake_minimum_required(VERSION 3.19)
+project(astrict)
+
+set(TARGET         astrict)
+set(PUBLIC_HDR_DIR include)
+
+# ==================================================================================================
+# Sources and headers
+# ==================================================================================================
+set(HDRS
+        include/astrict/CommonTypes.h
+        include/astrict/DebugCommon.h
+        include/astrict/DebugGlsl.h
+        include/astrict/FromGlsl.h
+        include/astrict/GlslTypes.h
+        include/astrict/ToGlsl.h)
+
+set(PRIVATE_HDRS)
+
+set(SRCS
+        src/DebugCommon.cpp
+        src/DebugGlsl.cpp
+        src/FromGlsl.cpp
+        src/ToGlsl.cpp)
+
+# ==================================================================================================
+# Include and target definitions
+# ==================================================================================================
+include_directories(${PUBLIC_HDR_DIR})
+include_directories(${CMAKE_BINARY_DIR})
+
+# astrict
+add_library(${TARGET} STATIC ${HDRS} ${PRIVATE_HDRS} ${SRCS})
+target_include_directories(${TARGET} PUBLIC ${PUBLIC_HDR_DIR})
+set_target_properties(${TARGET} PROPERTIES FOLDER Libs)
+target_link_libraries(${TARGET} backend_headers math utils)
+
+# We are being naughty and accessing private headers here
+# For spirv-tools, we're just following glslang's example
+target_include_directories(${TARGET} PRIVATE ${spirv-tools_SOURCE_DIR}/include)
+
+# glslang libraries have circular dependencies. To make sure the proper object are part of the link
+# we need to force archive re-scan on new symbol dependencies via start/end-group.
+# Read more about this here https://eli.thegreenplace.net/2013/07/09/library-order-in-static-linking
+if (APPLE OR MSVC)
+    target_link_libraries(${TARGET} glslang SPIRV SPIRV-Tools-opt spirv-cross-glsl)
+else()
+    target_link_libraries(${TARGET}
+            -Wl,--start-group glslang SPIRV SPIRV-Tools-opt spirv-cross-glsl -Wl,--end-group)
+endif()
+
+# ==================================================================================================
+# Compiler flags
+# ==================================================================================================
+# this must match options enabled in glslang's CMakeLists.txt
+target_compile_options(${TARGET} PRIVATE -DAMD_EXTENSIONS -DNV_EXTENSIONS )
+
+if (MSVC)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W0 /Zc:__cplusplus")
+endif()
+
+if (FILAMENT_ENABLE_MATDBG)
+    add_definitions(-DFILAMENT_ENABLE_MATDBG)
+endif()
+
+# ==================================================================================================
+# Installation
+# ==================================================================================================
+
+# Astrict has dependencies on a bunch of SPIRV-related libraries. To make things simpler, we bundle
+# them together into a single shared library and copy this into the installation folder. This
+# requires us to explicitly list the dependencies below, as CMake doesn't have a way to recursively
+# query dependencies.
+set(ASTRICT_DEPS
+        OGLCompiler
+        OSDependent
+        SPIRV
+        SPIRV-Tools
+        SPIRV-Tools-opt
+        astrict
+        glslang
+        spirv-cross-core
+        spirv-cross-glsl
+        spirv-cross-msl
+        )
+
+set(ASTRICT_COMBINED_OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/libastrict_combined.a")
+combine_static_libs(astrict "${ASTRICT_COMBINED_OUTPUT}" "${ASTRICT_DEPS}")
+
+set(ASTRICT_LIB_NAME ${CMAKE_STATIC_LIBRARY_PREFIX}astrict${CMAKE_STATIC_LIBRARY_SUFFIX})
+install(FILES "${ASTRICT_COMBINED_OUTPUT}" DESTINATION lib/${DIST_DIR} RENAME ${ASTRICT_LIB_NAME})
+install(DIRECTORY ${PUBLIC_HDR_DIR}/astrict DESTINATION include)
+
+# ==================================================================================================
+# Tests
+# ==================================================================================================
+project(test_astrict)
+set(TARGET test_astrict)
+set(SRCS
+        tests/test_FromGlsl.cpp)
+
+add_executable(${TARGET} ${SRCS})
+
+target_include_directories(${TARGET} PRIVATE src)
+
+target_link_libraries(${TARGET} astrict gtest)
+
+set_target_properties(${TARGET} PROPERTIES FOLDER Tests)
@@ -0,0 +1,86 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+
+#ifndef TNT_ASTRICT_ASTRICT_BUILDER_H
+#define TNT_ASTRICT_ASTRICT_BUILDER_H
+
+#include <set>
+#include <unordered_map>
+
+#include <astrict/CommonTypes.h>
+
+namespace astrict {
+
+using StringId = Newtype<int, struct StringIdTag>;
+using ExpressionId = Newtype<int, struct ExpressionIdTag>;
+using GlobalVariableId = Newtype<int, struct GlobalVariableIdTag>;
+using StructId = Newtype<int, struct StructIdTag>;
+using FunctionId = Newtype<int, struct FunctionIdTag>;
+
+using LocalVariableId = Newtype<int, struct LocalVariableIdTag>;
+
+template<typename Id, typename Value>
+class IdStore {
+public:
+    // Inserts if non-existent.
+    Id insert(Value value, bool* outWasExtant = nullptr) {
+        auto it = mMap.find(value);
+        if (it == mMap.end()) {
+            Id id(mMap.size() + 1);
+            mMap[value] = id;
+            if (outWasExtant) {
+                *outWasExtant = false;
+            }
+            return id;
+        }
+        if (outWasExtant) {
+            *outWasExtant = true;
+        }
+        return it->second;
+    }
+
+    std::vector<Value> getFinal() {
+        std::vector<Value> r(mMap.size());
+        for (const auto& pair : mMap) {
+            r[pair.second] = pair.first;
+        }
+        return r;
+    }
+
+private:
+    std::unordered_map<Value, Id> mMap;
+};
+
+using ByteVector = std::vector<uint8_t>;
+
+class AstrictBuilder {
+public:
+    std::vector<ByteVector> build();
+
+private:
+    IdStore<StringId, std::string> mStrings;
+    IdStore<ExpressionId, ByteVector> mExpressions;
+    IdStore<StructId, ByteVector> mStructs;
+    IdStore<GlobalVariableId, ByteVector> mGlobalSymbols;
+    IdStore<FunctionId, ByteVector> mFunctions;
+    IdStore<FunctionId, ByteVector> mFunctionBodies;
+    std::unordered_map<StructId, std::string> mStructNames;
+    std::unordered_map<GlobalVariableId, std::string> mGlobalVariableNames;
+};
+
+}  // namespace astrict
+
+#endif  // TNT_ASTRICT_ASTRICT_BUILDER_H
@@ -0,0 +1,473 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+
+#ifndef TNT_ASTRICT_COMMONTYPES_H
+#define TNT_ASTRICT_COMMONTYPES_H
+
+#include <variant>
+#include <vector>
+
+namespace astrict {
+
+template<typename T, typename Tag>
+class Newtype {
+public:
+    Newtype() : mValue() {}
+    Newtype(const Newtype<T, Tag> &other) : mValue(other.mValue) {}
+    Newtype(Newtype<T, Tag> &&other) : mValue(other.mValue) {}
+    explicit Newtype(T& value) : mValue(value) {}
+    explicit Newtype(T&& value) : mValue(value) {}
+
+    Newtype& operator=(const Newtype<T, Tag>& other) {
+        mValue = other.mValue;
+        return *this;
+    }
+
+    Newtype& operator=(Newtype<T, Tag>&& other) {
+        mValue = other.mValue;
+        return *this;
+    }
+
+    const T& operator*() const {
+        return mValue;
+    }
+
+    bool operator==(const Newtype<T, Tag>& o) const {
+        return mValue == o.mValue;
+    }
+
+    bool operator<(const Newtype<T, Tag>& o) const {
+        return mValue < o.mValue;
+    }
+private:
+    T mValue;
+};
+
+template<class>
+inline constexpr bool always_false_v = false;
+
+}  // namespace astrict
+
+namespace std {
+
+template<typename Tag>
+struct hash<astrict::Newtype<int, Tag>> {
+    std::size_t operator()(const astrict::Newtype<int, Tag>& o) const {
+        return *o;
+    }
+};
+
+template<typename Tag>
+struct hash<astrict::Newtype<uint16_t, Tag>> {
+    std::size_t operator()(const astrict::Newtype<uint16_t, Tag>& o) const {
+        return *o;
+    }
+};
+
+}  // namespace std
+
+namespace astrict {
+
+enum class BranchOperator : uint8_t {
+    Discard,             // Fragment only
+    TerminateInvocation, // Fragment only
+    Demote,              // Fragment only
+    TerminateRayEXT,         // Any-hit only
+    IgnoreIntersectionEXT,   // Any-hit only
+    Return,
+    Break,
+    Continue,
+    Case,
+    Default,
+};
+
+// Represents an operation whose syntax differs from a function call. For example, addition,
+// equality.
+enum class ExpressionOperator : uint8_t {
+    // Unary
+    Negative,
+    LogicalNot,
+    BitwiseNot,
+    PostIncrement,
+    PostDecrement,
+    PreIncrement,
+    PreDecrement,
+    ArrayLength,
+
+    // Binary
+    Add,
+    Sub,
+    Mul,
+    Div,
+    Mod,
+    RightShift,
+    LeftShift,
+    And,
+    InclusiveOr,
+    ExclusiveOr,
+    Equal,
+    NotEqual,
+    LessThan,
+    GreaterThan,
+    LessThanEqual,
+    GreaterThanEqual,
+    LogicalOr,
+    LogicalXor,
+    LogicalAnd,
+    Index,
+    Assign,
+    AddAssign,
+    SubAssign,
+    MulAssign,
+    DivAssign,
+    ModAssign,
+    AndAssign,
+    InclusiveOrAssign,
+    ExclusiveOrAssign,
+    LeftShiftAssign,
+    RightShiftAssign,
+
+    // Ternary
+    Ternary,
+
+    // Variadic
+    Comma,
+};
+
+using VariableOrExpressionId = std::variant<GlobalVariableId, LocalVariableId, ExpressionId>;
+
+struct StructMember {
+    StringId qualifier;
+    StringId type;
+
+    bool operator==(const StructMember& o) const {
+        return qualifier == o.qualifier
+                && type == o.type;
+    }
+};
+
+struct Struct {
+    StringId qualifier;
+    std::vector<StructMember> members;
+    std::vector<StringId> memberNames;
+
+    bool operator==(const Struct& o) const {
+        return qualifier == o.qualifier
+                && members == o.members
+                && memberNames == o.memberNames;
+    }
+};
+
+struct Type {
+    std::variant<StringId, StructId> name;
+    std::optional<StringId> qualifiers;
+    std::vector<std::size_t> arraySizes;
+
+    bool operator==(const Type& o) const {
+        return name == o.name
+                && qualifiers == o.qualifiers
+                && arraySizes == o.arraySizes;
+    }
+};
+
+struct Variable {
+    StringId qualifier;
+    StringId type;
+    std::optional<StringId> name;
+
+    bool operator==(const Variable& o) const {
+        return qualifier == o.qualifier
+                && type == o.type
+                && name == o.name;
+    }
+};
+
+struct ExpressionOperandExpression {
+    std::variant<ExpressionOperator, FunctionId, StructId> op;
+    std::vector<VariableOrExpressionId> args;
+
+    bool operator==(const ExpressionOperandExpression& o) const {
+        return op == o.op
+                && args == o.args;
+    }
+};
+
+struct VectorSwizzleExpression {
+    VariableOrExpressionId operand;
+    uint16_t swizzle;
+
+    bool operator==(const VectorSwizzleExpression& o) const {
+        return operand == o.operand
+                && swizzle == o.swizzle;
+    }
+};
+
+struct IndexStructExpression {
+    VariableOrExpressionId operand;
+    StructId strukt;
+    uint16_t index;
+
+    bool operator==(const IndexStructExpression& o) const {
+        return operand == o.operand
+                && strukt == o.strukt
+                && index == o.index;
+    }
+};
+
+struct LiteralExpression {
+    std::variant<
+        bool,
+        int,
+        double,
+        unsigned int> value;
+
+    bool operator==(const LiteralExpression& o) const {
+        return value == o.value;
+    }
+};
+
+using Expression = std::variant<
+    ExpressionOperandExpression,
+    VectorSwizzleExpression,
+    IndexStructExpression,
+    LiteralExpression>;
+
+struct Function {
+    FunctionId name;
+    TypeId returnType;
+    std::vector<LocalVariableId> parameters;
+    StatementBlockId body;
+    std::unordered_map<LocalVariableId, Variable> localVariables;
+
+    bool operator==(const Function& o) const {
+        return name == o.name
+                && returnType == o.returnType
+                && parameters == o.parameters
+                && body == o.body
+                && localVariables == o.localVariables;
+    }
+};
+
+struct IfStatement {
+    VariableOrExpressionId condition;
+    StatementBlockId thenBlock;
+    std::optional<StatementBlockId> elseBlock;
+
+    bool operator==(const IfStatement& o) const {
+        return condition == o.condition
+                && thenBlock == o.thenBlock
+                && elseBlock == o.elseBlock;
+    }
+};
+
+struct SwitchStatement {
+    VariableOrExpressionId condition;
+    StatementBlockId body;
+
+    bool operator==(const SwitchStatement& o) const {
+        return condition == o.condition
+                && body == o.body;
+    }
+};
+
+struct BranchStatement {
+    BranchOperator op;
+    std::optional<VariableOrExpressionId> operand;
+
+    bool operator==(const BranchStatement& o) const {
+        return op == o.op
+                && operand == o.operand;
+    }
+};
+
+struct LoopStatement {
+    VariableOrExpressionId condition;
+    std::optional<ExpressionId> terminal;
+    bool testFirst;
+    StatementBlockId body;
+
+    bool operator==(const LoopStatement& o) const {
+        return condition == o.condition
+                && terminal == o.terminal
+                && testFirst == o.testFirst
+                && body == o.body;
+    }
+};
+
+using Statement = std::variant<
+    ExpressionId,
+    IfStatement,
+    SwitchStatement,
+    BranchStatement,
+    LoopStatement>;
+
+template <typename T, typename... Rest>
+void hashCombine(std::size_t& seed, const T& v, const Rest&... rest) {
+    seed ^= std::hash<T>{}(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
+    (hashCombine(seed, rest), ...);
+}
+
+} // namespace astrict
+
+namespace std {
+
+template<>
+struct hash<astrict::StructMember> {
+    std::size_t operator()(const astrict::StructMember& o) const {
+        std::size_t result = 0;
+        astrict::hashCombine(result, o.name, o.type);
+        return result;
+    }
+};
+
+template<>
+struct hash<astrict::Struct> {
+    std::size_t operator()(const astrict::Struct& o) const {
+        std::size_t result = 0;
+        astrict::hashCombine(result, o.name, o.members.size());
+        for (const auto& member : o.members) {
+            astrict::hashCombine(result, member);
+        }
+        return result;
+    }
+};
+
+template<>
+struct hash<astrict::Type> {
+    std::size_t operator()(const astrict::Type& o) const {
+        std::size_t result = 0;
+        astrict::hashCombine(result, o.name, o.qualifiers, o.arraySizes.size());
+        for (const auto& size : o.arraySizes) {
+            astrict::hashCombine(result, size);
+        }
+        return result;
+    }
+};
+
+template<>
+struct hash<astrict::Variable> {
+    std::size_t operator()(const astrict::Variable& o) const {
+        std::size_t result = 0;
+        astrict::hashCombine(result, o.name, o.type);
+        return result;
+    }
+};
+
+template<>
+struct hash<astrict::ExpressionOperandExpression> {
+    std::size_t operator()(const astrict::ExpressionOperandExpression& o) const {
+        std::size_t result = 0;
+        astrict::hashCombine(result, o.op, o.args.size());
+        for (const auto& arg : o.args) {
+            astrict::hashCombine(result, arg);
+        }
+        return result;
+    }
+};
+
+template<>
+struct hash<astrict::IndexStructExpression> {
+    std::size_t operator()(const astrict::IndexStructExpression& o) const {
+        std::size_t result = 0;
+        astrict::hashCombine(result, o.operand, o.strukt, o.index);
+        return result;
+    }
+};
+
+template<>
+struct hash<astrict::VectorSwizzleExpression> {
+    std::size_t operator()(const astrict::VectorSwizzleExpression& o) const {
+        std::size_t result = 0;
+        astrict::hashCombine(result, o.operand, o.swizzle);
+        return result;
+    }
+};
+
+template<>
+struct hash<astrict::LiteralExpression> {
+    std::size_t operator()(const astrict::LiteralExpression& o) const {
+        std::size_t result = 0;
+        astrict::hashCombine(result, o.value);
+        return result;
+    }
+};
+
+template<>
+struct hash<astrict::Function> {
+    std::size_t operator()(const astrict::Function& o) const {
+        std::size_t result = 0;
+        astrict::hashCombine(result, o.name, o.returnType, o.body,
+                o.parameters.size(), o.localVariables.size());
+        for (const auto& argument : o.parameters) {
+            astrict::hashCombine(result, argument);
+        }
+        for (const auto& symbol : o.localVariables) {
+            astrict::hashCombine(result, symbol.first, symbol.second);
+        }
+        return result;
+    }
+};
+
+template<>
+struct hash<astrict::IfStatement> {
+    std::size_t operator()(const astrict::IfStatement& o) const {
+        std::size_t result = 0;
+        astrict::hashCombine(result, o.condition, o.thenBlock, o.elseBlock);
+        return result;
+    }
+};
+
+template<>
+struct hash<astrict::SwitchStatement> {
+    std::size_t operator()(const astrict::SwitchStatement& o) const {
+        std::size_t result = 0;
+        astrict::hashCombine(result, o.condition, o.body);
+        return result;
+    }
+};
+
+template<>
+struct hash<astrict::BranchStatement> {
+    std::size_t operator()(const astrict::BranchStatement& o) const {
+        std::size_t result = 0;
+        astrict::hashCombine(result, o.op, o.operand);
+        return result;
+    }
+};
+
+template<>
+struct hash<astrict::LoopStatement> {
+    std::size_t operator()(const astrict::LoopStatement& o) const {
+        std::size_t result = 0;
+        astrict::hashCombine(result, o.condition, o.terminal, o.testFirst, o.body);
+        return result;
+    }
+};
+
+template<>
+struct hash<std::vector<astrict::Statement>> {
+    std::size_t operator()(const std::vector<astrict::Statement>& o) const {
+        std::size_t result = o.size();
+        for (const auto& statement : o) {
+            astrict::hashCombine(result, statement);
+        }
+        return result;
+    }
+};
+
+}  // namespace std
+
+#endif  // TNT_ASTRICT_COMMONTYPES_H
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+
+#ifndef TNT_ASTRICT_DEBUGCOMMON_H
+#define TNT_ASTRICT_DEBUGCOMMON_H
+
+#include <astrict/CommonTypes.h>
+
+namespace astrict {
+
+const char* rValueOperatorToString(ExpressionOperator op);
+
+} // namespace astrict
+
+#endif  // TNT_ASTRICT_DEBUGCOMMON_H
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+
+#ifndef TNT_ASTRICT_DEBUGGLSL_H
+#define TNT_ASTRICT_DEBUGGLSL_H
+
+#include "glslang/Include/intermediate.h"
+
+namespace astrict {
+
+const char* glslangOperatorToString(glslang::TOperator op);
+std::string glslangNodeToString(const TIntermNode* node);
+std::string glslangLocToString(const glslang::TSourceLoc& loc);
+std::string glslangNodeToStringWithLoc(const TIntermNode* node);
+
+} // namespace astrict
+
+#endif  // TNT_ASTRICT_DEBUGGLSL_H
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+
+#ifndef TNT_ASTRICT_FROMGLSL_H
+#define TNT_ASTRICT_FROMGLSL_H
+
+#include <astrict/GlslTypes.h>
+
+#include "glslang/Include/intermediate.h"
+
+namespace astrict {
+
+PackFromGlsl fromGlsl(const glslang::TIntermediate& intermediate);
+
+} // namespace astrict
+
+#endif  // TNT_ASTRICT_FROMGLSL_H
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+
+#ifndef TNT_ASTRICT_GLSLTYPES_H
+#define TNT_ASTRICT_GLSLTYPES_H
+
+#include <astrict/CommonTypes.h>
+#include <set>
+#include <unordered_map>
+#include <vector>
+
+namespace astrict {
+
+struct PackFromGlsl {
+    int version;
+    std::unordered_map<StringId, std::string> strings;
+    std::unordered_map<TypeId, Type> types;
+    std::unordered_map<StructId, Struct> structs;
+    std::unordered_map<GlobalVariableId, Variable> globalVariables;
+    std::unordered_map<ExpressionId, Expression> expressions;
+    std::unordered_map<FunctionId, std::string> functionNames;
+    std::unordered_map<StatementBlockId, std::vector<Statement>> statementBlocks;
+    std::unordered_map<FunctionId, Function> functions;
+    // The below serve as the roots for conversion to glsl.
+    std::vector<StructId> structsInOrder;
+    std::set<FunctionId> functionPrototypes;
+    std::vector<std::pair<GlobalVariableId, VariableOrExpressionId>> globalSymbolsInOrder;
+    std::vector<FunctionId> functionsInOrder;
+};
+
+};
+
+#endif  // TNT_ASTRICT_GLSLTYPES_H
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+
+#ifndef TNT_ASTRICT_TOGLSL_H
+#define TNT_ASTRICT_TOGLSL_H
+
+#include <astrict/GlslTypes.h>
+#include <sstream>
+
+namespace astrict {
+
+void toGlsl(const PackFromGlsl& pack, std::ostringstream& out);
+
+};
+
+#endif  // TNT_ASTRICT_TOGLSL_H
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Eliza Velasquez	0709f7d59a	stuff	2024-03-06 15:02:15 -08:00
Eliza Velasquez	2027c9e237	stuff	2024-02-28 16:05:28 -08:00
Eliza Velasquez	86456c9e34	swizzle! struct indexing!	2024-02-27 17:04:25 -08:00
Eliza Velasquez	fad58ba892	insert room for literal operand expressions	2024-02-27 15:39:40 -08:00
Eliza Velasquez	8ae296974c	rename bunch of stuff	2024-02-27 14:31:32 -08:00
Eliza Velasquez	f9575675d9	more global symbols	2024-02-27 12:54:41 -08:00
Eliza Velasquez	71025cf25a	stringify, flesh out global symbols	2024-02-26 16:54:05 -08:00
Eliza Velasquez	a067fb02b1	finish get_if	2024-02-26 14:37:14 -08:00
Eliza Velasquez	ffde51ee6f	continue eradicating get_if	2024-02-26 13:13:25 -08:00
Eliza Velasquez	35f99ed168	templatify	2024-02-23 15:07:18 -08:00
Eliza Velasquez	a939ad03f8	stuff	2024-02-22 17:01:54 -08:00
Eliza Velasquez	05e628fff9	more codegen	2024-02-22 15:52:42 -08:00
Eliza Velasquez	ad8473760a	start literal value support	2024-02-21 17:09:01 -08:00
Eliza Velasquez	cb672eb063	more rigorous glsl code gen	2024-02-21 16:04:20 -08:00
Eliza Velasquez	9811b785cb	split locals and globals	2024-02-20 16:40:52 -08:00
Eliza Velasquez	ff6d4d721e	major refactor	2024-02-20 14:08:07 -08:00
Eliza Velasquez	c8a5094c41	stuff	2024-02-16 15:03:53 -08:00
Eliza Velasquez	0f34603cfc	stringify stuff	2024-02-14 17:11:24 -08:00
Eliza Velasquez	300f80448d	test	2024-02-13 16:58:49 -08:00
Eliza Velasquez	a41d343a75	wip: komi	2024-02-12 16:59:06 -08:00
Mathias Agopian	02f5903b67	fix external images It turns out that many drivers require to rebind the external texture after its content has changed, so we now always do that. Bug #6188	2024-01-26 14:17:48 -08:00
Mathias Agopian	c39a870abc	fix mobile debug builds, missing incluldes	2024-01-26 11:14:16 -08:00
Mathias Agopian	09b8008e17	add missing public headers in backend	2024-01-26 10:58:28 -08:00
Mathias Agopian	59b59cf6be	add missing includes in libutils public headers	2024-01-26 10:58:00 -08:00
Mathias Agopian	0df6013263	update remote ui	2024-01-26 10:57:37 -08:00
Mathias Agopian	d5041fced7	support execinfo.h on Android 33 and above Note: this currently requires to compile filament with API_LEVEL 33.	2024-01-25 14:50:29 -08:00
Mathias Agopian	9c54b8a777	fix typo that broke FSR upscaling	2024-01-25 10:34:47 -08:00
Mathias Agopian	8a534d0940	Fix missing/extra includes in all public headers	2024-01-24 23:13:14 -08:00
Mathias Agopian	130825422e	Shadowmap texture vizualizer The vizualizer is implemented inside filament itself and activated using the debug registry. This intended for filament development use.	2024-01-24 11:28:11 -08:00
Powei Feng	984006ee25	geometry: allow additional attributes in TangentSpaceMesh (#7483 ) - Add methods for adding attributes to the input mesh - Add method in TangentSpaceMesh for when user provides the tangents - Separate client-side Algorithm enum from implementation algorithm (AlgorithmImpl) - Fix CMake config for combining static libs	2024-01-23 16:16:35 -08:00
Sungun Park	b676002521	Release Filament 1.50.0	2024-01-23 21:10:06 +00:00
Sungun Park	8bdf7bd1e5	Update material version to 50	2024-01-22 15:25:06 -08:00
Mathias Agopian	1262cb286c	backend option to disable parallel shader compile	2024-01-22 12:43:27 -08:00
Mathias Agopian	ee6f3fb1dc	Add sharpening option to TAA We use the RCAS algorithm from FSR1. This is useful for when TAA upscaling is enabled and similar to to what FSR2 is doing.	2024-01-19 14:40:04 -08:00
Mathias Agopian	b9a9586abb	taa: add a 32-sample mode and cleanup 32 sample may be more suited to 2x upsampling, it gives 8 samples per high-res pixel (instead of 4). This is also what FSR 2.0 is using, which is useful for comparing.	2024-01-19 14:40:04 -08:00
Mathias Agopian	6ee20a57aa	remove all uses of our custom spinlock This has caused issues and over time we have reduced the use of spinlocks, it was only used in few places and we still have evidence that it's causing ANRs. We use utils::Mutex instead which is a low overhead mutex implementation on Linux systems. FIXES=[321101014]	2024-01-19 12:05:07 -08:00
Mathias Agopian	368fa2bf39	fix IBLPrefilterContext::EquirectangularToCubemap it was incorrectly mapping the equirect image to a cubemap due to a typo in our overload of atan2 which was swapping its parameters. atan2 is now removed, and we use atan(y,x) instead. Also modified the code slightly so it matches almost exactly cmgen's. FIXES=[320856413]	2024-01-18 21:10:21 -08:00
Mathias Agopian	8f642892b4	taa: fixes input filtering option=OFF when upscaling is off when upscaling is off, the confidence value is always 1.	2024-01-18 21:07:13 -08:00
Powei Feng	5435a8ed3b	Add missing includes (#7501 ) BUG=320668410	2024-01-17 11:04:42 -08:00