Merge branch 'rc/1.17.0' into release

Move the command generation of the structure pass into its execute 
block, meaning that if the structure pass is culled, the command 
generation is now skipped too.

.github/ISSUE_TEMPLATE/bug_report.md

@@ -17,6 +17,10 @@ A clear and concise description of what you expected to happen.
 **Screenshots**
 If applicable, add screenshots to help explain your problem.
 
+**Logs**
+If applicable, copy logs from your console here. Please *do not*
+use screenshots of logs, copy them as text.
+
 **Desktop (please complete the following information):**
  - OS: [e.g. iOS]
  - GPU: [e.g. NVIDIA GTX 1080]

.github/workflows/linux-continuous.yml

@@ -10,7 +10,7 @@ on:
 jobs:
   build-linux:
     name: build-linux
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-18.04
 
     steps:
       - uses: actions/checkout@v2.0.0

.github/workflows/mac-continuous.yml

@@ -21,3 +21,6 @@ jobs:
         with:
           name: filament-mac
           path: out/filament-release-darwin.tgz
+      - name: Check public headers
+        run: |
+          build/common/check-headers.sh out/release/filament/include

.github/workflows/presubmit.yml

@@ -1,6 +1,12 @@
 name: Presubmit
 
-on: [pull_request]
+on:
+  push:
+    branches:
+    - main
+  pull_request:
+    branches:
+    - main
 
 jobs:
   build-desktop:
@@ -9,7 +15,7 @@ jobs:
 
     strategy:
       matrix:
-        os: [macos-latest, ubuntu-latest]
+        os: [macos-latest, ubuntu-18.04]
 
     steps:
       - uses: actions/checkout@v2.0.0

.github/workflows/release.yml

@@ -1,14 +1,25 @@
 name: Release
 
 # This Workflow can be triggered two ways:
-# 1. A GitHub release is created (using the GitHub web UI). This triggers all of the platforms to build and upload assets.
-# 2. A repository_dispatch API event is sent. This triggers a build for only the platform specified in the dispatch event.
+# 1. A GitHub release is created (using the GitHub web UI). This triggers all of the platforms to
+# build and upload assets.
+# 2. A workflow_dispatch event is triggered from the GitHub web UI. This triggers a build for only
+# the platform specified in the dispatch event.
 
 env:
-  RELEASE_TAG: ${{ github.event.client_payload.release_tag }}
+  RELEASE_TAG: ${{ github.event.inputs.release_tag }}
 
 on:
-  repository_dispatch:
+  workflow_dispatch:
+    inputs:
+      platform:
+        description: 'Platform to build (desktop, web, android, ios, windows)'
+        required: true
+        default: 'desktop'
+      release_tag:
+        description: 'Release tag to build (e.g., v1.13.0)'
+        required: true
+        default: 'v1.13.0'
   release:
     types: [created]
 
@@ -16,11 +27,11 @@ jobs:
   build-desktop:
     name: build-desktop
     runs-on: ${{ matrix.os }}
-    if: github.event_name == 'release' || github.event.client_payload.platform == 'desktop'
+    if: github.event_name == 'release' || github.event.inputs.platform == 'desktop'
 
     strategy:
       matrix:
-        os: [macos-latest, ubuntu-latest]
+        os: [macos-latest, ubuntu-18.04]
 
     steps:
       - name: Decide Git ref
@@ -51,7 +62,7 @@ jobs:
   build-web:
     name: build-web
     runs-on: macos-latest
-    if: github.event_name == 'release' || github.event.client_payload.platform == 'web'
+    if: github.event_name == 'release' || github.event.inputs.platform == 'web'
 
     steps:
       - name: Decide Git ref
@@ -80,7 +91,7 @@ jobs:
   build-android:
     name: build-android
     runs-on: macos-latest
-    if: github.event_name == 'release' || github.event.client_payload.platform == 'android'
+    if: github.event_name == 'release' || github.event.inputs.platform == 'android'
 
     steps:
       - name: Decide Git ref
@@ -96,6 +107,20 @@ jobs:
       - name: Run build script
         run: |
           cd build/android && printf "y" | ./build.sh release
+      - name: Sign sample-gltf-viewer
+        run: |
+          echo "${APK_KEYSTORE_BASE64}" > filament.jks.base64
+          base64 --decode filament.jks.base64 > filament.jks
+          BUILD_TOOLS_VERSION=$(ls ${ANDROID_HOME}/build-tools | sort -V | tail -n 1)
+          APKSIGNER=${ANDROID_HOME}/build-tools/${BUILD_TOOLS_VERSION}/apksigner
+          IN_FILE="out/sample-gltf-viewer-release.apk"
+          OUT_FILE="out/filament-gltf-viewer-${TAG}-android.apk"
+          ${APKSIGNER} sign --ks filament.jks --key-pass=pass:${APK_KEYSTORE_PASS} --ks-pass=pass:${APK_KEYSTORE_PASS} --in ${IN_FILE} --out ${OUT_FILE}
+          rm "${IN_FILE}"
+        env:
+          TAG: ${{ steps.git_ref.outputs.tag }}
+          APK_KEYSTORE_BASE64: ${{ secrets.APK_KEYSTORE_BASE64 }}
+          APK_KEYSTORE_PASS: ${{ secrets.APK_KEYSTORE_PASS }}
       - name: Upload release assets
         run: |
           pip3 install setuptools
@@ -107,7 +132,7 @@ jobs:
           mv out/gltfio-android-lite-release.aar out/gltfio-${TAG}-lite-android.aar
           mv out/filament-utils-android-release.aar out/filament-utils-${TAG}-android.aar
           mv out/filament-utils-android-lite-release.aar out/filament-utils-${TAG}-lite-android.aar
-          python3 build/common/upload-assets.py ${TAG} out/*.aar
+          python3 build/common/upload-assets.py ${TAG} out/*.aar out/*.apk
         env:
           TAG: ${{ steps.git_ref.outputs.tag }}
           GITHUB_API_KEY: ${{ secrets.GITHUB_API_KEY }}
@@ -115,7 +140,7 @@ jobs:
   build-ios:
     name: build-ios
     runs-on: macos-latest
-    if: github.event_name == 'release' || github.event.client_payload.platform == 'ios'
+    if: github.event_name == 'release' || github.event.inputs.platform == 'ios'
 
     steps:
       - name: Decide Git ref
@@ -144,7 +169,7 @@ jobs:
   build-windows:
     name: build-windows
     runs-on: windows-latest
-    if: github.event_name == 'release' || github.event.client_payload.platform == 'windows'
+    if: github.event_name == 'release' || github.event.inputs.platform == 'windows'
 
     steps:
       - name: Decide Git ref

.gitignore

@@ -12,3 +12,7 @@ filament/docs/html/**
 *tmp*.png
 civetweb.txt
 /TAGS
+settings.json
+test*.png
+test*.json
+results

BRANCHING.md

@@ -0,0 +1,29 @@
+![Filament branching strategy](art/diagrams/branching.png)
+
+## Which branch do I open my PR against?
+
+For normal development, open PRs against main. Once they're merged, no further action is necessary.
+
+If you discover a bug with the latest *release candidate*, open a bug fix PR against the release
+candidate branch (rc/1.9.0, for example). Once the PR is merged, decide whether it makes sense for
+the fix to also go into main. If it was a temporary fix, simply make the _correct_ fix in main as
+you would any other change. If the fix is good for main as well, use `git cherry-pick <sha>` to
+cherry-pick it into main.
+
+If an immediate hotfix is needed on the *release* branch, open a PR against the release branch. Once
+the PR is merged, decide whether the fix is temporary or permanent. If the fix was temporary, make
+the _correct_ fix in both the next release candidate branch _and_ main. If the fix is good, use `git
+cherry-pick <sha>` to cherry-pick it into the relase candidate branch and main.
+
+## What consitutes a bug?
+
+Only bug fix PRs should be opened against the *release candidate* branch.
+
+Bugs are defined as one of the following _introduced since the prior release_:
+
+- crashes
+- rendering issues
+- unintentional binary size increases
+- unintentional public API changes
+
+For example, a long-standing crash just recently discovered would not necessitate a bug fix PR.

BUILDING.md

@@ -4,29 +4,23 @@
 
 To build Filament, you must first install the following tools:
 
-- CMake 3.10 (or more recent)
+- CMake 3.19 (or more recent)
 - clang 7.0 (or more recent)
-- [ninja 1.8](https://github.com/ninja-build/ninja/wiki/Pre-built-Ninja-packages) (or more recent)
-
-To build the Java based components of the project you can optionally install (recommended):
-
-- OpenJDK 1.8 (or more recent)
+- [ninja 1.10](https://github.com/ninja-build/ninja/wiki/Pre-built-Ninja-packages) (or more recent)
 
 Additional dependencies may be required for your operating system. Please refer to the appropriate
 section below.
 
 To build Filament for Android you must also install the following:
 
-- Android Studio 4.0.1 or more recent
+- Android Studio Arctic Fox or more recent
 - Android SDK
-- Android NDK "side-by-side" 21.3 or higher
+- Android NDK "side-by-side" 23.1 or higher
 
 ### Environment variables
 
-Make sure the environment variable `ANDROID_HOME` points to the location of your Android SDK.
-
-By default our build system will attempt to compile the Java bindings. To do so, the environment
-variable `JAVA_HOME` should point to the location of your JDK.
+To build Filament for Android, make sure the environment variable `ANDROID_HOME` points to the
+location of your Android SDK.
 
 When building for WebGL, you'll also need to set `EMSDK`. See [WebAssembly](#webassembly).
 
@@ -65,25 +59,13 @@ To install the libraries and executables in `out/debug/` and `out/release/`, add
 You can force a clean build by adding the `-c` flag. The script offers more features described
 by executing `build.sh -h`.
 
-### Disabling Java builds
-
-By default our build system will attempt to compile the Java bindings. If you wish to skip this
-compilation step simply pass the `-j` flag to `build.sh`:
-
-```
-$ ./build.sh -j release
-```
-
-If you use CMake directly instead of the build script, pass `-DFILAMENT_ENABLE_JAVA=OFF`
-to CMake instead.
-
 ### Filament-specific CMake Options
 
 The following CMake options are boolean options specific to Filament:
 
-- `FILAMENT_ENABLE_JAVA`:          Compile Java projects: requires a JDK and the JAVA_HOME env var
 - `FILAMENT_ENABLE_LTO`:           Enable link-time optimizations if supported by the compiler
 - `FILAMENT_BUILD_FILAMAT`:        Build filamat and JNI buildings
+- `FILAMENT_SUPPORTS_OPENGL`:      Include the OpenGL backend
 - `FILAMENT_SUPPORTS_METAL`:       Include the Metal backend
 - `FILAMENT_SUPPORTS_VULKAN`:      Include the Vulkan backend
 - `FILAMENT_INSTALL_BACKEND_TEST`: Install the backend test library so it can be consumed on iOS
@@ -162,14 +144,6 @@ make sure the command line tools are setup by running:
 $ xcode-select --install
 ```
 
-After installing Java 1.8 you must also ensure that your `JAVA_HOME` environment variable is
-properly set. If it doesn't already point to the appropriate JDK, you can simply add the following
-to your `.profile`:
-
-```
-export JAVA_HOME="$(/usr/libexec/java_home)"
-```
-
 Then run `cmake` and `ninja` to trigger a build:
 
 ```
@@ -317,11 +291,11 @@ Alternatively you can build the AAR from the command line by executing the follo
 `android/` directory:
 
 ```
-$ ./gradlew -Pfilament_dist_dir=../../out/android-release/filament assembleRelease
+$ ./gradlew -Pcom.google.android.filament.dist-dir=../../out/android-release/filament assembleRelease
 ```
 
-The `-Pfilament_dist_dir` can be used to specify a different installation directory (it must match
-the CMake install prefix used in the previous steps).
+The `-Pcom.google.android.filament.dist-dir` can be used to specify a different installation
+directory (it must match the CMake install prefix used in the previous steps).
 
 #### Using Filament's AAR
 
@@ -375,7 +349,7 @@ same version that our continuous builds use.
 
 ```
 cd <your chosen parent folder for the emscripten SDK>
-curl -L https://github.com/emscripten-core/emsdk/archive/1.39.19.zip > emsdk.zip
+curl -L https://github.com/emscripten-core/emsdk/archive/2.0.23.zip > emsdk.zip
 unzip emsdk.zip ; mv emsdk-* emsdk ; cd emsdk
 python ./emsdk.py install latest
 python ./emsdk.py activate latest
@@ -422,12 +396,13 @@ filamesh ./assets/models/monkey/monkey.obj monkey.filamesh
 ```
 
 Most samples accept an IBL that must be generated using the `cmgen` tool (`./tools/filamesh/cmgen`
-in your build directory). These sample apps expect a path to a directory containing the '.rgb32f'
-files for the IBL (which are PNGs containing `R11F_G11F_B10F` data). To generate an IBL simply use
-this command:
+in your build directory). These sample apps expect a path to a directory containing the `.rgb32f`
+files for the IBL (which are PNGs containing `R11F_G11F_B10F` data) or a path to a directory
+containing two `.ktx` files (one for the IBL itself, one for the skybox). To generate an IBL
+simply use this command:
 
 ```
-cmgen -x ./ibls/ my_ibl.exr
+cmgen -f ktx -x ./ibls/ my_ibl.exr
 ```
 
 The source environment map can be a PNG (8 or 16 bit), a PSD (16 or 32 bit), an HDR or an OpenEXR
@@ -468,3 +443,19 @@ export SWIFTSHADER_LD_LIBRARY_PATH=`pwd`
 ```
 
 Next, go to your Filament repo and use the [easy build](#easy-build) script with `-t`.
+
+## SwiftShader for CI
+
+Continuous testing turnaround can be quite slow if you need to build SwiftShader from scratch, so we
+provide an Ubuntu-based Docker image that has it already built. The Docker image also includes
+everything necessary for building Filament. You can fetch and run the image as follows:
+
+```
+docker pull ghcr.io/filament-assets/swiftshader
+docker run -it ghcr.io/filament-assets/swiftshader
+```
+
+To do more with the container, see the helper script at `build/swiftshader/test.sh`.
+
+If you are a team member, you can update the public image to the latest SwiftShader by
+following the instructions at the top of `build/swiftshader/Dockerfile`.

CMakeLists.txt

@@ -1,7 +1,7 @@
 # ==================================================================================================
 # CMake
 # ==================================================================================================
-cmake_minimum_required(VERSION 3.10)
+cmake_minimum_required(VERSION 3.19)
 
 # ==================================================================================================
 # Project declaration
@@ -11,8 +11,6 @@ project(TNT)
 # ==================================================================================================
 # Options
 # ==================================================================================================
-option(FILAMENT_ENABLE_JAVA "Compile Java projects, requires a JDK and the JAVA_HOME env var" ON)
-
 option(FILAMENT_USE_EXTERNAL_GLES3 "Experimental: Compile Filament against OpenGL ES 3" OFF)
 
 option(FILAMENT_USE_SWIFTSHADER "Compile Filament against SwiftShader" OFF)
@@ -21,6 +19,20 @@ option(FILAMENT_ENABLE_LTO "Enable link-time optimizations if supported by the c
 
 option(FILAMENT_SKIP_SAMPLES "Don't build samples" OFF)
 
+option(FILAMENT_SUPPORTS_XCB "Include XCB support in Linux builds" ON)
+
+option(FILAMENT_SUPPORTS_XLIB "Include XLIB support in Linux builds" ON)
+
+option(FILAMENT_SUPPORTS_WAYLAND "Include Wayland support in Linux builds" OFF)
+
+option(FILAMENT_SKIP_SDL2 "Skip dependencies of SDL2, and SDL2" OFF)
+
+option(FILAMENT_LINUX_IS_MOBILE "Treat Linux as Mobile" OFF)
+
+set(FILAMENT_NDK_VERSION "" CACHE STRING
+    "Android NDK version or version prefix to be used when building for Android."
+)
+
 set(FILAMENT_PER_RENDER_PASS_ARENA_SIZE_IN_MB "2" CACHE STRING
     "Per render pass arena size. Must be roughly 1 MB larger than FILAMENT_PER_FRAME_COMMANDS_SIZE_IN_MB, default 2."
 )
@@ -33,8 +45,12 @@ set(FILAMENT_MIN_COMMAND_BUFFERS_SIZE_IN_MB "1" CACHE STRING
     "Size of the command-stream buffer. As a rule of thumb use the same value as FILAMENT_PER_FRRAME_COMMANDS_SIZE_IN_MB, default 1."
 )
 
-set(FILAMENT_OPENGL_HANDLE_ARENA_SIZE_IN_MB "2" CACHE STRING
-    "Size of the OpenGL handle arena, default 2."
+set(FILAMENT_OPENGL_HANDLE_ARENA_SIZE_IN_MB "4" CACHE STRING
+    "Size of the OpenGL handle arena, default 4."
+)
+
+set(FILAMENT_METAL_HANDLE_ARENA_SIZE_IN_MB "8" CACHE STRING
+    "Size of the Metal handle arena, default 8."
 )
 
 # ==================================================================================================
@@ -83,11 +99,35 @@ if (UNIX AND NOT APPLE AND NOT ANDROID AND NOT WEBGL)
     set(LINUX TRUE)
 endif()
 
-if (ANDROID OR WEBGL OR IOS)
+if (LINUX)
+    if (FILAMENT_SUPPORTS_WAYLAND)
+        add_definitions(-DFILAMENT_SUPPORTS_WAYLAND)
+        set(FILAMENT_SUPPORTS_X11 FALSE)
+    else ()
+        if (FILAMENT_SUPPORTS_XCB)
+            add_definitions(-DFILAMENT_SUPPORTS_XCB)
+        endif()
+
+        if (FILAMENT_SUPPORTS_XLIB)
+            add_definitions(-DFILAMENT_SUPPORTS_XLIB)
+        endif()
+
+        if (FILAMENT_SUPPORTS_XCB OR FILAMENT_SUPORTS_XLIB)
+            add_definitions(-DFILAMENT_SUPPORTS_X11)
+            set(FILAMENT_SUPPORTS_X11 TRUE)
+        endif()
+    endif()
+endif()
+
+if (ANDROID OR WEBGL OR IOS OR FILAMENT_LINUX_IS_MOBILE)
     set(IS_MOBILE_TARGET TRUE)
 endif()
 
-if (NOT ANDROID AND NOT WEBGL AND NOT IOS)
+if (ANDROID)
+    add_definitions(-D__ANDROID_UNAVAILABLE_SYMBOLS_ARE_WEAK__)
+endif()
+
+if (NOT ANDROID AND NOT WEBGL AND NOT IOS AND NOT FILAMENT_LINUX_IS_MOBILE)
     set(IS_HOST_PLATFORM TRUE)
 endif()
 
@@ -111,27 +151,35 @@ if (WIN32)
     # __declspec(dllexport) in front of each functions).
     set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
 
+    # The CMAKE_CXX_FLAGS vars can be overriden by some Visual Studio generators, so we use an alternative
+    # global method here:
     if (${USE_STATIC_CRT})
-        set(CRT_FLAGS_RELEASE "/MT")
-        set(CRT_FLAGS_DEBUG "/MTd")
+        add_compile_options(
+            $<$<CONFIG:>:/MT>
+            $<$<CONFIG:Debug>:/MTd>
+            $<$<CONFIG:Release>:/MT>
+        )
     else()
-        set(CRT_FLAGS_RELEASE "/MD")
-        set(CRT_FLAGS_DEBUG "/MDd")
+        add_compile_options(
+            $<$<CONFIG:>:/MD>
+            $<$<CONFIG:Debug>:/MDd>
+            $<$<CONFIG:Release>:/MD>
+        )
     endif()
 
     # TODO: Figure out why pdb generation messes with incremental compilaton.
     # IN RELEASE_WITH_DEBUG_INFO, generate debug info in .obj, no in pdb.
-    set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} ${CRT_FLAGS_RELEASE} /Z7")
-    set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO} ${CRT_FLAGS_RELEASE} /Z7")
+    set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} /Z7")
+    set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO} /Z7")
 
     # In RELEASE, also generate PDBs.
-    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${CRT_FLAGS_RELEASE} /Zi")
-    set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${CRT_FLAGS_RELEASE} /Zi")
+    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /Zi")
+    set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /Zi")
 
     # In DEBUG, avoid generating a PDB file which seems to mess with incremental compilation.
     # Instead generate debug info directly inside obj files.
-    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${CRT_FLAGS_DEBUG} /Z7")
-    set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} ${CRT_FLAGS_DEBUG} /Z7")
+    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /Z7")
+    set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /Z7")
 
     # Special settings when building on CI.
     if (${FILAMENT_WINDOWS_CI_BUILD})
@@ -248,7 +296,10 @@ if (LINUX)
     # /usr/bin/ld: ../bluegl/libbluegl.a(BlueGL.cpp.o): relocation R_X86_64_32S
     # against `.bss' can not be used when making a shared object; recompile with -fPIC
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC")
+endif()
 
+if (ANDROID)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC -Werror=unguarded-availability")
 endif()
 
 if (CYGWIN)
@@ -268,6 +319,12 @@ if (UNIX AND CMAKE_GENERATOR STREQUAL "Ninja")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fcolor-diagnostics")
 endif()
 
+# Use hidden by default and expose what we need.
+if (NOT WIN32)
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fvisibility=hidden")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden")
+endif()
+
 # ==================================================================================================
 # Release compiler flags
 # ==================================================================================================
@@ -282,7 +339,7 @@ endif()
 
 # On Android RELEASE builds, we disable exceptions and RTTI to save some space (about 75 KiB
 # saved by -fno-exception and 10 KiB saved by -fno-rtti).
-if (ANDROID OR WEBGL)
+if (ANDROID OR IOS OR WEBGL)
     set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -fno-exceptions -fno-unwind-tables -fno-asynchronous-unwind-tables -fno-rtti")
 endif()
 
@@ -348,6 +405,12 @@ if (CMAKE_BUILD_TYPE STREQUAL "Debug" OR CMAKE_BUILD_TYPE STREQUAL "RelWithDebIn
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DTNT_DEV")
 endif()
 
+# By default, build with support for OpenGL on all platforms.
+option(FILAMENT_SUPPORTS_OPENGL "Include the OpenGL backend" ON)
+if (FILAMENT_SUPPORTS_OPENGL)
+    add_definitions(-DFILAMENT_SUPPORTS_OPENGL)
+endif()
+
 # By default, build with Vulkan support on desktop platforms, although clients must request to use
 # it at run time.
 if (WIN32 OR WEBGL OR IOS)
@@ -383,6 +446,13 @@ else()
     option(FILAMENT_ENABLE_MATDBG "Enable the material debugger" OFF)
 endif()
 
+# Only optimize materials in Release mode (so error message lines match the source code)
+if (CMAKE_BUILD_TYPE MATCHES Release)
+    option(FILAMENT_DISABLE_MATOPT "Disable material optimizations" OFF)
+else()
+    option(FILAMENT_DISABLE_MATOPT "Disable material optimizations" ON)
+endif()
+
 # ==================================================================================================
 # Material compilation flags
 # ==================================================================================================
@@ -396,9 +466,9 @@ endif()
 
 set(MATC_API_FLAGS )
 
-# TODO: Add a flag to build Filament without support for OpenGL.
-set(MATC_API_FLAGS ${MATC_API_FLAGS} -a opengl)
-
+if (FILAMENT_SUPPORTS_OPENGL)
+    set(MATC_API_FLAGS ${MATC_API_FLAGS} -a opengl)
+endif()
 if (FILAMENT_SUPPORTS_VULKAN)
     set(MATC_API_FLAGS ${MATC_API_FLAGS} -a vulkan)
 endif()
@@ -406,9 +476,9 @@ if (FILAMENT_SUPPORTS_METAL)
     set(MATC_API_FLAGS ${MATC_API_FLAGS} -a metal)
 endif()
 
-# Only optimize materials in Release mode (so error message lines match the source code)
-if (NOT CMAKE_BUILD_TYPE MATCHES Release)
-    set(MATC_OPT_FLAGS -g)
+# Disable optimizations and enable debug info (preserves names in SPIR-V)
+if (FILAMENT_DISABLE_MATOPT)
+    set(MATC_OPT_FLAGS -gd)
 endif()
 
 set(MATC_BASE_FLAGS ${MATC_API_FLAGS} -p ${MATC_TARGET} ${MATC_OPT_FLAGS})
@@ -418,8 +488,23 @@ set(MATC_BASE_FLAGS ${MATC_API_FLAGS} -p ${MATC_TARGET} ${MATC_OPT_FLAGS})
 # ==================================================================================================
 # choose where to put the objects in the dist folder
 if (NOT DIST_ARCH)
-    set(DIST_ARCH x86_64)
+    # On Apple silicon, the value of CMAKE_HOST_SYSTEM_PROCESSOR varies based on the CMake process's
+    # own architecture. Because of this, running a x86_64 CMake binary on Apple silicon will cause
+    # DIST_ARCH to be set incorrectly.
+    set(DIST_ARCH "${CMAKE_HOST_SYSTEM_PROCESSOR}")
+
+    if (CMAKE_OSX_ARCHITECTURES MATCHES ".*;.*")
+        set(DIST_ARCH "universal")
+    else()
+        if (NOT "${CMAKE_OSX_ARCHITECTURES}" STREQUAL "")
+            set(DIST_ARCH "${CMAKE_OSX_ARCHITECTURES}")
+        endif()
+    endif()
+
 endif()
+# On Windows machines, the host processor is set to 'AMD64', which we'll interpret as x86_64.
+string(TOLOWER "${DIST_ARCH}" DIST_ARCH)
+string(REPLACE "amd64" "x86_64" DIST_ARCH "${DIST_ARCH}")
 if (NOT DIST_DIR)
     set(DIST_DIR "${DIST_ARCH}")
 endif()
@@ -437,11 +522,15 @@ function(list_licenses OUTPUT MODULES)
     foreach(module ${_MODULES})
         set(license_path "../../third_party/${module}/LICENSE")
         get_filename_component(fullname "${license_path}" ABSOLUTE)
-        string(APPEND CONTENT "${STR_OPENER}License and copyrights for ${module}:\n${STR_CLOSER},\n")
-        file(READ ${license_path} license_long)
-        string(REPLACE "\n" "${STR_CLOSER},\n${STR_OPENER}" license ${license_long})
-        string(APPEND CONTENT ${STR_OPENER}${license}\n${STR_CLOSER},)
-        string(APPEND CONTENT "\n\n")
+        if(EXISTS ${fullname})
+            string(APPEND CONTENT "${STR_OPENER}License and copyrights for ${module}:\n${STR_CLOSER},\n")
+            file(READ ${license_path} license_long)
+            string(REPLACE "\n" "${STR_CLOSER},\n${STR_OPENER}" license ${license_long})
+            string(APPEND CONTENT ${STR_OPENER}${license}\n${STR_CLOSER},)
+            string(APPEND CONTENT "\n\n")
+        else()
+            message(AUTHOR_WARNING "${license_path} not found. You can ignore this warning if you have devendored ${module}.")
+        endif()
     endforeach()
     configure_file(${FILAMENT}/build/licenses.inc.in ${OUTPUT})
 endfunction(list_licenses)
@@ -457,7 +546,12 @@ function(combine_static_libs TARGET OUTPUT DEPS)
     # Loop through the dependent libraries and query their location on disk.
     set(DEPS_FILES )
     foreach(DEPENDENCY ${DEPS})
-        list(APPEND DEPS_FILES "$<TARGET_FILE:${DEPENDENCY}>")
+        if(TARGET ${DEPENDENCY})
+            get_property(dep_type TARGET ${DEPENDENCY} PROPERTY TYPE)
+            if(dep_type STREQUAL "STATIC_LIBRARY")
+                list(APPEND DEPS_FILES "$<TARGET_FILE:${DEPENDENCY}>")
+            endif()
+        endif()
     endforeach()
 
     add_custom_command(
@@ -490,12 +584,14 @@ if (FILAMENT_USE_SWIFTSHADER)
     find_library(SWIFTSHADER_VK NAMES vk_swiftshader HINTS "$ENV{SWIFTSHADER_LD_LIBRARY_PATH}")
     message(STATUS "Found SwiftShader VK library in: ${SWIFTSHADER_VK}.")
     add_definitions(-DFILAMENT_VKLIBRARY_PATH=\"${SWIFTSHADER_VK}\")
-elseif (FILAMENT_SUPPORTS_VULKAN AND APPLE)
-    find_library(Vulkan_LIBRARY NAMES vulkan HINTS "$ENV{VULKAN_SDK}/lib" "$ENV{VULKAN_SDK}/macOS/lib")
-    if (Vulkan_LIBRARY)
-        set(Vulkan_FOUND ON)
-        message(STATUS "Found Vulkan library in SDK: ${Vulkan_LIBRARY}.")
-        add_definitions(-DFILAMENT_VKLIBRARY_PATH=\"${Vulkan_LIBRARY}\")
+elseif (FILAMENT_SUPPORTS_VULKAN)
+    if (APPLE OR FILAMENT_LINUX_IS_MOBILE)
+        find_library(Vulkan_LIBRARY NAMES vulkan HINTS "$ENV{VULKAN_SDK}/lib" "$ENV{VULKAN_SDK}/macOS/lib")
+        if (Vulkan_LIBRARY)
+            set(Vulkan_FOUND ON)
+            message(STATUS "Found Vulkan library in SDK: ${Vulkan_LIBRARY}.")
+            add_definitions(-DFILAMENT_VKLIBRARY_PATH=\"${Vulkan_LIBRARY}\")
+        endif()
     endif()
 endif()
 
@@ -544,23 +640,29 @@ add_subdirectory(${EXTERNAL}/libgtest/tnt)
 add_subdirectory(${LIBRARIES}/camutils)
 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)
 add_subdirectory(${LIBRARIES}/image)
 add_subdirectory(${LIBRARIES}/math)
 add_subdirectory(${LIBRARIES}/mathio)
 add_subdirectory(${LIBRARIES}/utils)
+add_subdirectory(${LIBRARIES}/viewer)
 add_subdirectory(${FILAMENT}/filament)
 add_subdirectory(${FILAMENT}/shaders)
+add_subdirectory(${EXTERNAL}/civetweb/tnt)
 add_subdirectory(${EXTERNAL}/hat-trie/tnt)
+add_subdirectory(${EXTERNAL}/imgui/tnt)
 add_subdirectory(${EXTERNAL}/robin-map/tnt)
 add_subdirectory(${EXTERNAL}/smol-v/tnt)
 add_subdirectory(${EXTERNAL}/benchmark/tnt)
 add_subdirectory(${EXTERNAL}/meshoptimizer)
 add_subdirectory(${EXTERNAL}/cgltf/tnt)
 add_subdirectory(${EXTERNAL}/draco/tnt)
+add_subdirectory(${EXTERNAL}/jsmn/tnt)
 add_subdirectory(${EXTERNAL}/stb/tnt)
 add_subdirectory(${EXTERNAL}/getopt)
 
@@ -574,7 +676,6 @@ if (FILAMENT_BUILD_FILAMAT OR IS_HOST_PLATFORM)
 
     # the material debugger requires filamat
     if (FILAMENT_ENABLE_MATDBG OR IS_HOST_PLATFORM)
-        add_subdirectory(${EXTERNAL}/civetweb/tnt)
         add_subdirectory(${LIBRARIES}/matdbg)
     endif()
 endif()
@@ -593,24 +694,19 @@ set(FILAMENT_SAMPLES_BINARY_DIR ${PROJECT_BINARY_DIR}/samples)
 if (WEBGL)
     add_subdirectory(web/filament-js)
     add_subdirectory(web/samples)
-    add_subdirectory(${EXTERNAL}/imgui/tnt)
 endif()
 
 if (IS_HOST_PLATFORM)
-    add_subdirectory(${LIBRARIES}/bluegl)
+    if (FILAMENT_SUPPORTS_OPENGL)
+        add_subdirectory(${LIBRARIES}/bluegl)
+    endif()
     add_subdirectory(${LIBRARIES}/filamentapp)
-    add_subdirectory(${LIBRARIES}/filagui)
     add_subdirectory(${LIBRARIES}/imageio)
 
-    add_subdirectory(${FILAMENT}/java/filamat)
-    add_subdirectory(${FILAMENT}/java/filament)
-    add_subdirectory(${FILAMENT}/java/gltfio)
-
     add_subdirectory(${FILAMENT}/samples)
 
     add_subdirectory(${EXTERNAL}/astcenc/tnt)
     add_subdirectory(${EXTERNAL}/etc2comp)
-    add_subdirectory(${EXTERNAL}/imgui/tnt)
     add_subdirectory(${EXTERNAL}/libassimp/tnt)
     add_subdirectory(${EXTERNAL}/libpng/tnt)
     add_subdirectory(${EXTERNAL}/libsdl2/tnt)
@@ -626,6 +722,7 @@ if (IS_HOST_PLATFORM)
     add_subdirectory(${TOOLS}/mipgen)
     add_subdirectory(${TOOLS}/normal-blending)
     add_subdirectory(${TOOLS}/resgen)
+    add_subdirectory(${TOOLS}/rgb-to-lmsr)
     add_subdirectory(${TOOLS}/roughness-prefilter)
     add_subdirectory(${TOOLS}/specular-color)
 endif()

README.md

@@ -31,39 +31,28 @@ repositories {
 }
 
 dependencies {
-    implementation 'com.google.android.filament:filament-android:1.9.0'
+    implementation 'com.google.android.filament:filament-android:1.17.0'
 }
 ```
 
 Here are all the libraries available in the group `com.google.android.filament`:
 
-[![filament-android](https://maven-badges.herokuapp.com/maven-central/com.google.android.filament/filament-android/badge.svg?subject=filament-android)](https://maven-badges.herokuapp.com/maven-central/com.google.android.filament/filament-android)  
-The Filament rendering engine itself.
-
-[![gltfio-android](https://maven-badges.herokuapp.com/maven-central/com.google.android.filament/gltfio-android/badge.svg?subject=gltfio-android)](https://maven-badges.herokuapp.com/maven-central/com.google.android.filament/gltfio-android)  
-A glTF 2.0 loader for Filament, depends on `filament-android`  .
-
-[![gltfio-android-lite](https://maven-badges.herokuapp.com/maven-central/com.google.android.filament/gltfio-android-lite/badge.svg?subject=gltfio-android-lite)](https://maven-badges.herokuapp.com/maven-central/com.google.android.filament/gltfio-android-lite)  
-Trimmed version of `gltfio` that does not support some glTF features.
-
-[![filament-utils-android](https://maven-badges.herokuapp.com/maven-central/com.google.android.filament/filament-utils-android/badge.svg?subject=filament-utils-android)](https://maven-badges.herokuapp.com/maven-central/com.google.android.filament/filament-utils-android)  
-KTX loading, Kotlin math, and camera utilities, depends on `gltfio-android`.
-
-[![filament-utils-android-lite](https://maven-badges.herokuapp.com/maven-central/com.google.android.filament/filament-utils-android-lite/badge.svg?subject=filament-utils-lite)](https://maven-badges.herokuapp.com/maven-central/com.google.android.filament/filament-utils-android-lite)  
-Trimmed version of `filament-utils` that does not support some glTF features.
-
-[![filamat-android](https://maven-badges.herokuapp.com/maven-central/com.google.android.filament/filamat-android/badge.svg?subject=filamat-android)](https://maven-badges.herokuapp.com/maven-central/com.google.android.filament/filamat-android)  
-A runtime material builder/compiler. This library is large but contains a full shader compiler/validator/optimizer.
-
-[![filamat-android-lite](https://maven-badges.herokuapp.com/maven-central/com.google.android.filament/filamat-android-lite/badge.svg?subject=filamat-android-lite)](https://maven-badges.herokuapp.com/maven-central/com.google.android.filament/filamat-android-lite)  
-A much smaller alternative to `filamat-android` that can only generate OpenGL shaders. It does not provide validation or optimizations.
+| Artifact      | Description   |
+| ------------- | ------------- |
+| [![filament-android](https://maven-badges.herokuapp.com/maven-central/com.google.android.filament/filament-android/badge.svg?subject=filament-android)](https://maven-badges.herokuapp.com/maven-central/com.google.android.filament/filament-android)  | The Filament rendering engine itself. |
+| [![gltfio-android](https://maven-badges.herokuapp.com/maven-central/com.google.android.filament/gltfio-android/badge.svg?subject=gltfio-android)](https://maven-badges.herokuapp.com/maven-central/com.google.android.filament/gltfio-android) | A glTF 2.0 loader for Filament, depends on `filament-android`. |
+| [![gltfio-android-lite](https://maven-badges.herokuapp.com/maven-central/com.google.android.filament/gltfio-android-lite/badge.svg?subject=gltfio-android-lite)](https://maven-badges.herokuapp.com/maven-central/com.google.android.filament/gltfio-android-lite) | Trimmed version of `gltfio` that does not support some glTF extensions. |
+| [![filament-utils-android](https://maven-badges.herokuapp.com/maven-central/com.google.android.filament/filament-utils-android/badge.svg?subject=filament-utils-android)](https://maven-badges.herokuapp.com/maven-central/com.google.android.filament/filament-utils-android) | KTX loading, Kotlin math, and camera utilities, depends on `gltfio-android`. |
+| [![filament-utils-android-lite](https://maven-badges.herokuapp.com/maven-central/com.google.android.filament/filament-utils-android-lite/badge.svg?subject=filament-utils-lite)](https://maven-badges.herokuapp.com/maven-central/com.google.android.filament/filament-utils-android-lite) | Trimmed version of `filament-utils` that does not support some glTF features. |
+| [![filamat-android](https://maven-badges.herokuapp.com/maven-central/com.google.android.filament/filamat-android/badge.svg?subject=filamat-android)](https://maven-badges.herokuapp.com/maven-central/com.google.android.filament/filamat-android) | A runtime material builder/compiler. This library is large but contains a full shader compiler/validator/optimizer and supports both OpenGL and Vulkan. |
+| [![filamat-android-lite](https://maven-badges.herokuapp.com/maven-central/com.google.android.filament/filamat-android-lite/badge.svg?subject=filamat-android-lite)](https://maven-badges.herokuapp.com/maven-central/com.google.android.filament/filamat-android-lite) | A much smaller alternative to `filamat-android` that can only generate OpenGL shaders. It does not provide validation or optimizations. |
 
 ### iOS
 
 iOS projects can use CocoaPods to install the latest release:
 
 ```
-pod 'Filament', '~> 1.9.0'
+pod 'Filament', '~> 1.17.0'
 ```
 
 ### Snapshots
@@ -97,25 +86,12 @@ steps:
 ![Helmet](docs/images/samples/example_helmet.jpg)
 ![Screen-space refraction](docs/images/samples/example_ssr.jpg)
 
-
-### Applications
-
-Here are a few screenshots of applications that use Filament in production:
-
-#### Google Maps AR Navigation
-
-![Google Maps AR Navigation](docs/images/samples/app_gmm_ar_nav.jpg)
-
-#### Google Search 3D/AR Viewer on Android
-
-![Google Search 3D/AR Viewer on Android](docs/images/samples/app_google_3d_viewer.jpg)
-
 ## Features
 
 ### APIs
 
 - Native C++ API for Android, iOS, Linux, macOS and Windows
-- Java/JNI API for Android, Linux, macOS and Windows
+- Java/JNI API for Android
 - JavaScript API
 
 ### Backends
@@ -131,29 +107,76 @@ Here are a few screenshots of applications that use Filament in production:
 - Clustered forward renderer
 - Cook-Torrance microfacet specular BRDF
 - Lambertian diffuse BRDF
+- Custom lighting/surface shading
 - HDR/linear lighting
 - Metallic workflow
 - Clear coat
 - Anisotropic lighting
 - Approximated translucent (subsurface) materials
-- Cloth shading
+- Cloth/fabric/sheen shading
 - Normal mapping & ambient occlusion mapping
 - Image-based lighting
 - Physically-based camera (shutter speed, sensitivity and aperture)
 - Physical light units
 - Point lights, spot lights and directional light
+- Specular anti-aliasing
 - Spot and directional light shadows
+- Cascaded shadows
+- EVSM, PCSS, DPCF, or PCF shadows
+- Transparent shadows
 - Contact shadows
 - Screen-space ambient occlusion
 - Screen-space refraction
 - Global fog
+- Dynamic resolution (with support for AMD FidelityFX FSR)
+
+### Post processing
+
 - HDR bloom
 - Depth of field bokeh
-- Multiple tone mappers: ACES, filmic, etc.
-- Color grading: white balance, channel mixer, shadows/mid-tones/highlights, ASC CDL,
-  contrast, saturation, etc.
-- TAA, FXAA, MSAA and specular anti-aliasing
-- Dynamic resolution
+- Multiple tone mappers: generic (customizable), ACES, filmic, etc.
+- Color and tone management: luminance scaling, gamut mapping
+- Color grading: exposure, night adaptation, white balance, channel mixer,
+  shadows/mid-tones/highlights, ASC CDL, contrast, saturation, etc.
+- TAA, FXAA, MSAA
+- Screen-space lens flares
+
+### glTF 2.0
+
+- Encodings
+  - [x] Embeded
+  - [x] Binary
+
+- Primitive Types
+  - [x] Points
+  - [x] Lines
+  - [ ] Line Loop
+  - [x] Line Strip
+  - [x] Triangles
+  - [x] Triangle Strip
+  - [ ] Triangle Fan
+
+- Animation
+  - [x] Transform animation
+  - [x] Linear interpolation
+  - [x] Morph animation
+    - [x] Sparse accessor
+  - [x] Skin animation
+  - [x] Joint animation
+
+- Extensions
+  - [x] KHR_draco_mesh_compression
+  - [x] KHR_lights_punctual
+  - [x] KHR_materials_clearcoat
+  - [x] KHR_materials_ior
+  - [x] KHR_materials_pbrSpecularGlossiness
+  - [x] KHR_materials_sheen
+  - [x] KHR_materials_transmission
+  - [x] KHR_materials_unlit
+  - [x] KHR_materials_volume
+  - [x] KHR_mesh_quantization
+  - [x] KHR_texture_transform
+
 
 ## Rendering with Filament
 
@@ -218,22 +241,11 @@ if (renderer->beginFrame(swapChain)) {
 ```
 
 For complete examples of Linux, macOS and Windows Filament applications, look at the source files
-in the `samples/` directory. These samples are all based on `samples/app/` which contains the code
-that creates a native window with SDL2 and initializes the Filament engine, renderer and views.
+in the `samples/` directory. These samples are all based on `libs/filamentapp/` which contains the
+code that creates a native window with SDL2 and initializes the Filament engine, renderer and views.
 
-### Java on Linux, macOS and Windows
-
-After building Filament, you can use `filament-java.jar` and its companion `filament-jni` native
-library to use Filament in desktop Java applications.
-
-You must always first initialize Filament by calling `Filament.init()`.
-
-You can use Filament either with AWT or Swing, using respectively a `FilamentCanvas` or a
-`FilamentPanel`.
-
-Following the steps above (how to use Filament from native code), create an `Engine` and a
-`Renderer`, but instead of calling `beginFrame` and `endFrame` on the renderer itself, call
-these methods on `FilamentCanvas` or `FilamentPanel`.
+For more information on how to prepare environment maps for image-based lighting please refer to
+[BUILDING.md](https://github.com/google/filament/blob/main/BUILDING.md#running-the-native-samples).
 
 ### Android
 
@@ -264,6 +276,10 @@ To get started you can use the textures and environment maps found respectively
 `third_party/textures` and `third_party/environments`. These assets are under CC0 license. Please
 refer to their respective `URL.txt` files to know more about the original authors.
 
+Environments must be pre-processed using
+[`cmgen`](https://github.com/google/filament/blob/main/BUILDING.md#running-the-native-samples) or
+using the `libiblprefilter` library.
+
 ## How to make contributions
 
 Please read and follow the steps in [CONTRIBUTING.md](/CONTRIBUTING.md). Make sure you are
@@ -286,9 +302,9 @@ and tools.
 - `docs`:                     Documentation
   - `math`:                   Mathematica notebooks used to explore BRDFs, equations, etc.
 - `filament`:                 Filament rendering engine (minimal dependencies)
+  - `backend`:                Rendering backends/drivers (Vulkan, Metal, OpenGL/ES)
 - `ide`:                      Configuration files for IDEs (CLion, etc.)
 - `ios`:                      Sample projects for iOS
-- `java`:                     Java bindings for Filament libraries
 - `libs`:                     Libraries
   - `bluegl`:                 OpenGL bindings for macOS, Linux and Windows
   - `bluevk`:                 Vulkan bindings for macOS, Linux, Windows and Android
@@ -308,6 +324,7 @@ and tools.
   - `math`:                   Math library
   - `mathio`:                 Math types support for output streams
   - `utils`:                  Utility library (threads, memory, data structures, etc.)
+  - `viewer`:                 glTF viewer library (requires gltfio)
 - `samples`:                  Sample desktop applications
 - `shaders`:                  Shaders used by `filamat` and `matc`
 - `third_party`:              External libraries and assets

RELEASE_GUIDE.md

@@ -0,0 +1,140 @@
+# Filament Release Guide
+
+This guide makes use of some "environment variables":
+- $RELEASE = the new version of Filament we are releasing today. (e.g., 1.9.3)
+- $NEXT_RELEASE = the version we plan to release next week (e.g., 1.9.4)
+
+Before starting, ensure that each of these branches is up-to-date with origin:
+- release
+- rc/$RELEASE
+- main
+
+## 0. Make sure the rc/$RELEASE branch has the correct version.
+
+It should have the version corresponding to its name, $RELEASE.
+
+## 1. Update RELEASE_NOTES.md on the rc branch.
+
+Checkout the rc/$RELEASE branch. In RELEASE_NOTES.md, locate the header corresponding to $RELEASE
+and write release notes. To see which commits make up the release, run:
+
+```
+build/common/release.sh -c rc/$RELEASE
+```
+
+Commit the changes to rc/$RELEASE with the title:
+
+```
+Update RELEASE_NOTES for $RELEASE
+```
+
+## 2. Bump versions on main to $RELEASE.
+
+Checkout main and run the following command to bump Filament's version to $RELEASE:
+
+```
+build/common/bump-version.sh $RELEASE
+```
+
+Commit changes to main with the title:
+
+```
+Release Filament $RELEASE
+```
+
+Do not push to origin yet.
+
+## 3. Cherry-pick RELEASE_NOTES change from rc branch to main.
+
+```
+git cherry-pick rc/$RELEASE
+```
+
+Update the headers. The "Next release" header becomes a header for $NEXT_RELEASE, and a new "Next
+release" header is added.
+
+For example, this:
+
+```
+## Next release (main branch)
+- foo
+- bar
+
+## v1.9.3
+- baz
+- bat
+```
+
+becomes:
+
+```
+## Next release (main branch)
+
+## v1.9.4
+- foo
+- bar
+
+## v1.9.3
+- baz
+- bat
+```
+
+Ammend these changes to the cherry-picked change.
+
+```
+git add -u
+git commit --amend --no-edit
+```
+
+## 4. Run release script.
+
+```
+build/common/release.sh rc/$RELEASE rc/$NEXT_RELEASE
+```
+
+This script will merge rc/$RELEASE into release, delete the rc branch, and create a new rc
+branch called rc/$NEXT_RELEASE. Verify that everything looks okay locally.
+
+## 5. Push the release branch.
+
+```
+git push origin release
+```
+
+## 6. Create the GitHub release.
+
+Use the GitHub UI to create a GitHub release corresponding to $RELEASE version.
+Make sure the target is set to the release branch.
+
+## 7. Delete the old rc branch (optional).
+
+This step is optional. The old rc branch may be left alive for a few weeks for posterity.
+
+```
+git push origin --delete rc/$RELEASE
+```
+
+## 8. Bump the version on the new rc branch to $NEXT_RELEASE.
+
+```
+git checkout rc/$NEXT_RELEASE
+build/common/bump-version.sh $NEXT_RELEASE
+```
+
+Commit the changes to rc/$NEXT_RELEASE with the title:
+
+```
+Bump version to $NEXT_RELEASE
+```
+
+## 9. Push main.
+
+```
+git push origin main
+```
+
+## 10. Push the new rc branch.
+
+```
+git push origin -u rc/$NEXT_RELEASE
+```

RELEASE_NOTES.md

@@ -3,7 +3,558 @@
 This file contains one line summaries of commits that are worthy of mentioning in release notes.
 A new header is inserted each time a *tag* is created.
 
-## Next release
+## v1.17.1 (currently main branch)
+
+## v1.17.0
+
+- engine: Add experimental glossy screen-space reflections.
+- engine: Add support for GPU morphing and 128 morph targets.
+- engine: Fix crash with non-shadow receiving renderables and VSM.
+- engine: Bring back the 3x3 filter for PCF shadows.
+- engine: Correct AABB calculation for skinned glTF models.
+
+## v1.16.1
+
+- engine: Added line/triangle strip support.
+
+## v1.16.0
+
+- engine: Fixes skinning calculations (#4887) [⚠️ **Material breakage**].
+- engine: Add support for the glTF extension KHR_materials_emissive_strength.
+- engine: Improvements and fixes to skinning calculations.
+- engine: Fix debug checks for compressed textures.
+- Metal: Fix `readPixels` when dimensions are greater than the render target's.
+
+## v1.15.2
+
+- engine: add support for PCSS (Percentage Closer Soft Shadows).
+- engine: fix spotlight shadow bias.
+- samples: avoid leaking IBLs in Android sample-gltf-viewer.
+- libs: fix `libibl` on mobile.
+
+## v1.15.1
+
+- engine: add support for DPCF (PCF shadows with contact hardening).
+- engine: add support for Wayland and Vulkan.
+- engine: Fade lights out when close to light far plane.
+- Java: Add missing `Engine#destroySkinningBuffer` method.
+
+## v1.15.0
+
+- engine: Fix spotlights normal bias calculation [⚠️ **Material breakage**].
+- libimage: Fix loading spherical harmonics on certain locals.
+
+## v1.14.2
+
+- Metal: Fix validation error when rendering to `RenderTarget` without depth attachment.
+- engine: Fix rendering glitch with zero-scale bone transforms.
+
+## v1.14.1
+
+- engine: Improvements to shadowing.
+
+## v1.14.0
+
+- engine: Internal materials can use structures as parameters [⚠️ **Material breakage**].
+- engine: `readPixels` on a `SwapChain` must be called within `beginFrame` / `endFrame` [⚠️ **API
+  Change**].
+- engine: Fix normal bias and improve spotlight quality.
+- Java: Fix shadow biases.
+
+## v1.13.0
+
+- Android: Gradle configuration caching is now enabled.
+- Android: Filament's Gradle properties have all been renamed to `com.google.android.filament.xxx`
+  where `xxx` is the property name. See `android/build.gradle` for a complete list [⚠️]
+- Android: The Gradle property `filament_tools_dir` (now called
+  `com.google.android.filament.tools-dir`) does not have a default value anymore. Please specify one
+  in your `gradle.properties` if you reuse the Gradle plugin in your projects [⚠️]
+- engine: Fix spotlights direction and falloff [⚠️ **Material breakage**].
+- engine: Improvements to VSM and spotlight shadows.
+
+## v1.12.11
+
+- Metal: Color grading performance improvement on M1 devices.
+- samples: Fix glitchy animation seen in gltf-viewer iOS sample.
+
+## v1.12.10
+
+- engine: rewrite dynamic resolution scaling controller for better accuracy and less jittering.
+- Java: fix missing ASTC texture enum.
+- tools: Fix normal map issues in mipgen.
+- WebGL: expose some `SurfaceOrientation` functions.
+
+## v1.12.9
+
+- engine: New API: `MultiSampleAntiAliasingOptions` and HDR-aware MSAA resolve. When `customResolve`
+  is enabled, improves anti-aliasing quality [**NEW API**].
+- engine: Fixes and improvements for FSR.
+- engine: All APIs that take a callback as argument now also take a `CallbackHandler*`, a new
+  interface that provides more flexibility around callback dispatch [**NEW API**].
+- Android: Fix JNI bindings for `DepthOfFieldOptions`.
+- Android: workarounds for Adreno-specific fraembuffer issue.
+- JavaScript: updates to JS bindings.
+
+## v1.12.8
+
+- engine: Added picking API to `View`  [⚠️ **Materials need to be rebuilt to access this new feature**].
+- engine: A new `Engine::pumpMessageQueues()` method can be used to trigger all pending user
+  callbacks right away [**NEW API**].
+- engine: new inline helpers to more easily use lambdas, functors and method callbacks with
+  `{Pixel}BufferDescriptor`.
+- Vulkan: fix vertical offset for `readPixels`.
+- Vulkan: various internal improvements.
+- Metal: support integer formats with `readPixels`.
+
+## v1.12.7
+
+- engine: Fix, apply emissive after shadowing.
+
+## v1.12.6
+
+- engine: Added concept of lod bias to materials.
+  [⚠️ **Materials need to be rebuilt to access this new feature**].
+- engine: Fix, BGRA ordering respected for external images with OpenGL on iOS.
+- engine: Use more sensible defaults for spot light inner outer cone angles.
+- engine: Fix potential race condition that caused stalls in `endFrame`.
+- gltfio: Improved handling of transparent materials.
+- Metal: Fix potential crash on earlier versions of iOS (<= 13.0).
+- Android: Fix `filament-utils-android` 'lite' flavor.
+- Java: Fix potential crash with `IBLPrefilter`.
+
+## v1.12.5
+
+- engine: work around a job scheduling issue in `endFrame` that caused stuttering on some Android
+devices.
+
+## v1.12.4
+
+- engine: New night adaptation API on `ColorGrading`. This API can be used to create an effect that
+  that simulates color and brightness shifts in human vision in low-light conditions.
+- engine: improved performance of AMD FidelityFX FSR1 by 4.6x, it now runs in about 2ms in 4K.
+- engine: Dynamic resolution quality `MEDIUM`, `HIGH` and `ULTRA` now all use AMD FidelityFX FSR1.
+- engine: Fix crash when duplicating material instances.
+- gltfio: generate tangents if requested by the material.
+
+## v1.12.3
+
+- engine: Support AMD FidelityFX Super Resolution for dynamic resolution scaling
+
+## v1.12.2
+
+- engine: New API on `ColorGrading` to enable or disable gamut mapping at will [**New API**].
+- engine: Fix typo causing ShadowOptions::shadowFar to not work properly.
+- engine: Fix, CSM glitch when using shadowMultiplier materials.
+- engine: Improve precision when computing camera projection.
+- engine: Increase the number of supported spot shadows to 14 (from 6).
+- Metal: Add texture swizzling support for external textures.
+
+## v1.12.1
+
+- engine: `double` precision translation support in TransformManager. Disabled by default.
+  Augment model (and view) matrix on `Camera` to accept double precision matrices. When enabled,
+  double precision translations allow filament to handle a very large world space [**New API**].
+- engine: Fix, Views with custom render targets are now blendable.
+
+## v1.12.0
+
+- engine: Option to automatically compute bent normals from SSAO & apply to specular AO
+  [⚠️ **Material breakage**].
+- engine: New APIs: Light channels. Geometry and lights now have a channel associated to them, at
+  least one channel must match for lighting to occur [⚠️ **Material breakage**].
+- engine: Fix potential GPU crash with punctual lights near the far clipping plane.
+- materials: The `inverseTonemap` API is now an exact inverse of the Filmic tonemapper.
+- Metal: Better support for texture formats on M1 Macs.
+
+## v1.11.2
+
+- engine: New API: `ColorGrading::Builder::toneMapper(const ToneMapper*)`.
+- engine: New tone mapper: `GenericToneMapper`, a configurable tone mapper.
+- engine: `ColorGrading::Builder::toneMapping(ColorGrading::ToneMapping)` is now deprecated.
+- engine: Removed `REINHARD` tonemap operator[⚠️ **API Change**].
+- engine: Improve s3tc_srgb detection on desktop.
+- engine: Add bilateral threshold in SSAO options.
+- gltfio: Fix AssetLoader leak, remove unwanted destructor.
+- Metal/Vulkan: Fix uploading texture data with padding or offset.
+- Metal: fix GPU crash seen with large amounts of geometry.
+
+## v1.11.1
+
+- engine: Luminance scaling can now be used with any tone mapping operator. It was previously tied
+  to the "EVILS" tone mapping operator.
+- engine: Removed the "EVILS" tone mapping operator [⚠️ **API Change**].
+- engine: Improvements to Skinning. A new `SkinningBuffer` API allows bone sharing between
+  renderables.
+- engine: Improvements to internal memory allocation for Metal and Vulkan backends.
+- engine: Default to OpenGL backend when Windows does not support Vulkan.
+- samples: Add new sample app: image_viewer.
+
+## v1.11.0
+
+- engine: Added support for transparent shadows. Add `transparentShadow : true` in the material file.
+- engine: honor user-defined precision in material files for non-samplers, rename `SamplerPrecision`
+  to `ParameterPrecicion`. [⚠️ **API Change**]
+- engine: Work around Qualcomm issue with point lights.
+- engine: Allow MSAA when post-processing is disabled.
+- engine: enable up to 6 spot-light shadows.
+- gltfio: Added support for `KHR_materials_volume`.
+- gltfio: fix precision in KHR_texture_transform.
+- java: Removed support for Java desktop targets (macOS, Linux, and Windows) [⚠️ **API Change**].
+
+## v1.10.7
+
+- engine: Spot-light position calculation moved to fragment shader.
+- engine: Small shadow mapping fixes and improvements.
+- gltfio: Add fast path for native material providers.
+- gltfio: Allow Java / Kotlin clients to customize MaterialProvider.
+- engine: Fix out of bounds access with `RenderTarget` java bindings.
+- Metal: `TextureFormat::DEPTH24_STENCIL8` now maps to a 32 bit depth format on iOS.
+
+## v1.10.6
+
+- engine: Use exponential VSM and improve VSM user settings [⚠️ **Recompile Materials for VSM**].
+- engine: Optional blurring of VSM shadowmaps.
+- engine: Fix a crash when using lens flares.
+- engine: Fix backend crashes when using an unsupported sample count.
+- gltfio: Add new `getAsset`API to `FilamentInstance`.
+- gltfio: Introduce support for extras strings.
+- OpenGL: Increase OpenGL backend handle arena from 2 to 4 MiB.
+- Vulkan: Fix Texture swizzle support.
+
+## v1.10.5
+
+- android: AAR libraries now properly include their ProGuard rules.
+- engine: User materials can now provide custom lighting/surface shading, please consult
+  the [materials documentation](https://google.github.io/filament/Materials.html) for details.
+- engine: `Backend::DEFAULT` now selects the most appropriate backend for the platform, rather than
+  always `OPENGL`. On Android the default is `OPENGL`, on Apple platforms the default is `METAL` and
+  on all other platforms that default is `VULKAN`.
+- engine: Fix a potential memory corruption when using more than 4 render targets.
+- engine: Fix a possible crash when bloom is enabled.
+- engine: Fix and refactor support for S3TC + SRGB with OpenGL.
+- engine: Fix automatic clearing of rendertargets.
+- engine: Fix imported render target discard and clear flags.
+- engine: Fix opaque blit with imported render targets.
+
+## v1.10.4
+
+- engine: improvements to internal job system.
+- Vulkan: performance improvements on Mali.
+- gltfio: improvements to load time for large models.
+- WebGL: remove bogus stride argument, fix `BindingType` TypeScript definition.
+
+## v1.10.3
+
+- android: use `debug.filament.backend` system property to select the desired backend.
+- engine: fix `LightManager::getFalloff`.
+- gltfio: fix crash with non-triangles.
+- macOS: fix main thread checker warnings with OpenGL.
+- vulkan: fix crash on Windows machines with NVIDIA GPUs.
+
+## v1.10.2
+
+- Vulkan: validation and diagnostic improvements
+- engine: improvements for scenes with many renderables.
+- gltfio: added support for `KHR_materials_ior`.
+- java: Add bindings for `IBLPrefilterContext`.
+- java: add `KTXLoader.getSphericalHarmonics` JNI binding
+- libimage: fix, respect sRGB option for compressed formats.
+- sample-gltf-viewer: fix lifetime cycle for RemoteServer.
+
+## v1.10.1
+
+- engine: Add `getPlatform` API to Engine.
+- engine: Add a new cone angles API to `LightManager`.
+- engine: Attachments of custom RendereTargets are not systematically discarded.
+- engine: Fix a crash when using custom rendertargets.
+- engine: New API to duplicate a `MaterialInstance`.
+- filagui: fix support for custom images in ImGuiHelper.
+- java: Add bindings for HDRLoader.
+
+## v1.10.0
+
+- engine: User materials can now use 9 samplers instead of 8 [⚠️ **Material breakage**].
+- engine: Remove `populateTangentQuaternions`  [⚠️ **API change**].
+- engine: Deprecate `Stream::Builder::stream(intptr_t)` [⚠️ **API Change**].
+- engine: Remove deprecated APIs: `Camera::setScaling`, `Engine::destroy(Camera*)`,
+  `Engine::createCamera`, `Renderer::beginFrame(SwapChain*, uint64_t,
+  backend::FrameScheduledCallback, void*)`, and `View::setShadowsEnabled` [⚠️ **API Change**].
+- engine: Remove `focusDistance` from `View::BloomOptions` [⚠️ **API Change**].
+- engine: Add a `FILAMENT_SUPPORTS_OPENGL` CMake option to enable/disable OpenGL support.
+- Vulkan: fixes and improvements for large scenes.
+- gltfio: fix morphing bugs uncovered by MorphStressTest.
+- Java: add API for `Texture::Builder::import()`.
+- WebGL: Fix a potential INVALID_OPERATION.
+
+## v1.9.25
+
+- NEW API: Screen-space lens flare effect.
+- engine: Fix several memory leaks in the GL backend.
+- Vulkan: General bug fixes and improvements.
+- Vulkan: Fix some problems seen on Mali devices.
+- ios: Fix VSM shadows not working.
+- webgl: Fix black screen seen with some samples.
+
+## v1.9.24
+
+- engine: Fix memory leaks in OpenGL driver.
+- engine: new experimental tone mapper, `EVILS` (name will most likely change).
+- engine: Improvements to Vulkan backend.
+- engine: Fix incorrect units documented for `LightManager.getIntensity`.
+- engine: fix high quality upsampling for SSAO.
+- engine: implement accurate normal reconstruction for SSAO.
+- engine: improve LOW and HIGH quality levels for SSAO.
+- libs: improvements to `libiblprefilter`.
+- materials: New `quality` property.
+- samples: Add new gltf-viewer iOS sample.
+- samples: clear the background in lightbulb sample.
+
+## v1.9.23
+
+- Vulkan: various fixes.
+- android: fix crash seen using VSM with MSAA on Adreno devices.
+- engine: Add `Engine::getEntityManager()`.
+- engine: Fix desktop crash seen with some GPU drivers.
+- engine: improve importance sampling.
+- gltfio: robustness improvements for Draco meshes.
+- libs: Add new Transcoder API for C++ clients (part of `libgeometry`).
+- libs: New `iblprefilter` library to compute IBL pre-integration on the GPU using filament.
+- materials: Fix documentation for `getNormalizedViewportCoord`.
+- samples: fix rendertarget sample crash on launch.
+
+## v1.9.22
+
+- NEW API: `Renderer::renderStandaloneView()` is a new method that can be used outside of
+  beginFrame/endFrame on Views that have a RenderTarget associated. This can be used as a
+  pseudo-compute API.
+- Vulkan: bug fixes and improvements.
+- engine: RenderTarget API can now use MRT.
+- sample-gltf-viewer: improvements for reading zip files.
+- sample-gltf-viewer: enable contact-shadows functionality in mobile gltf-viewer.
+- windows: fix build error in filament_framegraph_test.
+
+## v1.9.21
+
+- JavaScript: add missing TextureSampler bindings.
+- Metal: Fix texture swizzling crash with older Nvidia GPUs.
+- Vulkan: fix image layout validation error on Android.
+- android: fix MSAA w/ multisampled_render_to_texture on Mali.
+- engine: better anisotropic filtering with various drivers.
+- gltfio: Use BufferObject API, simplify MorphHelper.
+- gltfio: honor stride in normalizeSkinningWeights.
+- samples: Add web component demo.
+
+## v1.9.20
+
+- Android: Fix VSM.
+- engine: Introduce BufferObject API.
+- engine: Add new isTextureSwizzleSupported API on Texture.
+- engine: Add support to Metal and Vulkan backends for texture swizzling.
+- engine: Add new DoF settings (native/half res, gather kernel ring counts, CoC radius clamp).
+- engine: DoF quality and performance improvements.
+- engine: Fix high-quality upsampling issue with SSAO.
+- Java: Expose `TransformManager.getParent(int)`.
+- samples: Add Metal and Vulkan backend support to Suzanne sample.
+- WebGL: expose fitIntoUnitCube to JS.
+- WebGL: support for multiple `<canvas>` elements.
+
+## v1.9.19
+
+- engine: Fix Metal bug when setGeometryAt is called multiple times.
+- engine: Improvements to DoF.
+- engine: Fix RenderTarget NPE when depth is not present.
+- engine: Improvements to Camera APIs. Move focus distance from DofOptions to Camera.
+- engine: VSM shadows now support `shadowMultiplier`.
+- java: Expose severla MaterialInstance APIs (setColorWrite, setDepthWrite, setDepthCulling) that
+  should have been public.
+- java: fix bug with Texture::setImage buffer size calculation.
+
+## v1.9.18
+
+- engine: Fix a DoF bug that caused black dots around the fast tiles.
+- engine: Minor DoF optimizations.
+- engine: Fix blanking windows not being drawn into on macOS.
+- gltfio: Add support for data:// in image URI's.
+- gltfio: Add internal MorphHelper, enable up to 255 targets.
+- engine: Fix a hang in JobSystem.
+- samples: Fix rendertarget sample app.
+
+## v1.9.17
+
+- engine: New shift parameter on `Camera` to translate the viewport and emulate a tilt/shift lens.
+- engine: `Camera::setCustomProjection()` now allows to set a different projection for culling and rendering.
+- engine: Fixed depth of field rendering with custom projection matrices.
+- engine: Fix a rare indefinite hang.
+- gltfio: `SimpleViewer` now exposes more rendering parameters, including `ColorGrading`.
+- gltfio: Fix tangents when morphing is enabled.
+- Metal/Vulkan: fix incorrect dominant light shadows rendering.
+- Fixe some issues with imported rendertargets.
+
+## v1.9.16
+
+gltfio: Add ResourceLoader evict API.
+gltfio: Fix ResourceLoader cache bug.
+iOS: Disable exceptions to reduce binary size.
+
+## v1.9.15
+
+- filamat/matc: fix sporadic crash.
+
+## v1.9.14
+
+- Improve bloom/emissive with glTF files.
+- Publicly expose Exposure API for gltfio.
+
+## v1.9.13
+
+- Android: fix "No implementation found" error.
+- Android: fix compilation error in UbershaderLoader.
+- engine: computeDataSize now returns correct value for USHORT_565.
+- Vulkan: various internal improvements.
+
+## v1.9.12
+
+- engine: Fixed GL errors seen with MSAA on WebGL.
+  Warning: this can affect multisampling behavior on devices that do not support OpenGL ES 3.1
+- materials: Added new `getVertexIndex()` API for vertex shaders.
+- samples: RenderTarget demo now disables post-processing in offscreen view and creates depth attachment.
+- gltfio: Fix, animation jolt when time delta is very small.
+
+## v1.9.11
+
+- Added support for Apple silicon Macs. build.sh can now be used to build on either Apple silicon or
+  Intel-based Macs. Pass the `-l` flag to build universal binaries.
+- Added `sheenColor` and `sheenRoughness` properties to materials to create cloth/fabric.
+- Materials generation using `libfilamat` is now multi-threaded.
+- `MaterialBuilder::build()` now expects a reference to a `JobSystem` to multi-thread shaders
+  generation. A `JobSystem` can be obtained with `Engine::getJobSystem()` when using Filament,
+  or created directly otherwise. (⚠️ **API change**)
+- Add planar reflection RenderTarget demo.
+- Metal: honor inverseFrontFaces RasterState.
+- Metal: Fix crash when switching between views with shadowing enabled.
+- Metal: Fix crash when calling Texture::setImage() on SAMPLER_2D_ARRAY texture.
+- gltfio: added support for `KHR_materials_sheen`.
+- gltfio: shader optimizations are now disabled by default, unless opting in or using ubershaders.
+- gltfio: Fix "_maskThreshold not found" error.
+- gltfio on Java: fix potential memory leak in AssetLoader#destroy.
+- gltfio: fix crash during async texture decode.
+- gltfio: support animation in dynamically-added instances.
+- gltfio: Improve robustness when decoding textures.
+- gltfio: Fix animator crash for orphaned nodes.
+- gltfio: fix tangents with morphing.
+- gltf_viewer: fix very sporadic crash when exiting.
+- gltf_viewer: fix crash when rapidly switching between glTF models.
+- WebGL: Fix samples erroring on Windows with Chrome.
+- WebGL: Support `highlight` for setBloomOptions in JavaScript.
+- WebGL: Include TypeScript bindings in releases.
+- engine: Fix, punctual lights get clipped at certain angles.
+- engine: Fix memory leak when calling `View::setViewport` frequently.
+- engine: Fix, materials not working on some Qualcomm devices.
+- engine: Modulate emissive by alpha on blended objects.
+- engine: Fix, RenderTarget cleared multiple times.
+- Java: Fix JNI bindings for color grading.
+- Android: reduced binary size.
+
+## v1.9.10
+
+- Introduce `libibl_lite` library.
+- engine: Fix `EXC_BAD_INSTRUCTION` seen when using headless SwapChains on macOS with OpenGL.
+- engine: Add new callback API to `SwapChain`.
+- engine: Fix SwiftShader crash when using an IBL without a reflections texture.
+- filamat: Shrink internal `Skybox` material size.
+- filamat: improvements to generated material size.
+- filamat: silence spirv-opt warnings in release builds.
+- matc: Add fog variant filter.
+- matc: Fix crash when building mobile materials.
+- math: reduce template bloat for matrices.
+
+## v1.9.9
+
+- Vulkan: internal robustness improvements.
+- Metal: Support CVPixelBuffer SwapChains.
+- Metal: Support copyFrame.
+- Fix clear behavior with RenderTarget API.
+- Fix GetRefractionMode JNI binding.
+- Additional fixes for Fence bug.
+
+## v1.9.8
+
+- Fix a few Fence-related bugs
+- gltfio: add createInstance() to AssetLoader.
+- gltfio: fix ASAN issue when consuming invalid animation.
+- gltfio: do not segfault on invalid primitives.
+- gltfio: add safety checks to getAnimator.
+- gltfio: fix segfault when consuming invalid file.
+- Vulkan: various internal refactoring and improvements
+- mathio: add ostream operator for quaternions.
+- Fix color grading not applied when dithering is off.
+
+## v1.9.7
+
+- Vulkan: improvements to the ReadPixels implementation.
+- Vulkan: warn instead of panic for sampler overflow.
+- Vulkan: fix leak with headless swap chain.
+- PlatformVkLinux now supports all combos of XLIB and XCB.
+- Fix TypeScript binding for TextureUsage.
+
+## v1.9.6
+
+- Added View::setVsmShadowOptions (experimental)
+- Add anisotropic shadow map sampling with VSM (experimental)
+- matc: fixed bug where some compilation failures still exited with code 0
+- Vulkan + Android: fix build break
+- Add optional XCB support to PlatformVkLinux
+- Fix Vulkan black screen on Windows with NVIDIA hardware
+
+## v1.9.5
+
+- Added a new Live Wallpaper Android sample
+- `UiHelper` now supports managing a `SurfaceHolder`
+- Fix: an internal texture resource was never destroyed
+- Fix: hang on 2-CPU machines
+- Fix: Vulkan crash when using shadow cascades
+- Linux fixes for headless SwiftShader
+- Fix null pointer dereference in `FIndirectLight`
+- Fix Windows build by avoiding nested initializers
+- Vulkan: support readPixels and headless swap chains
+- VSM improvements
+
+## v1.9.4
+
+- Add screen space cone tracing (SSCT)
+- Improvements to VSM shadow quality
+- New `ShadowOptions` control to render Variance Shadow Maps (VSM) with MSAA (experimental)
+- Improvements and fixes to screen-space ambient occlusion
+- gltf_viewer: add --headless option
+- gltf_viewer: Add new automation UI and functionality
+
+## v1.9.3
+
+- engine: Added new APIs to enable/disable screen space refraction
+- engine: Fix, flip the shading normal when det < 0.
+- gltfio: Fix animation by clamping the per-channel interpolant.
+- gltfio: add async cancellation API
+- gltfio: Fix "uniform not found" errors.
+- gltfio: Disable clear coat layer IOR change in glTF files (#3104)
+- Vulkan: fix final image barrier used for swap chain.
+- matdbg: Various improvements
+- JavaScript bindings: fix TextureUsage bitmask.
+- cmgen / mipgen: add opt-in for ASTC / ETC support.
+
+## v1.9.2
+
+- Fixes / improvements for contact shadows, fog, and DOF
+- Reduce SSAO creases caused by geometry tessellation
+- Fix compilation warnings and issue with Clang 12
+- Fix JNI crashes
+- Rename .blurScale to .cocScale in DOF options
+
+## v1.9.1
+
+- Improvements to SSAO quality
+- Fix unoptimized shader crashes with certain OpenGL drivers
+- Add float versions of math constants to libmath
+- filament-utils: fix, `CoroutineScope` job should be canceled before destroy
 
 ## v1.9.0
 

android/Windows.md

@@ -6,11 +6,29 @@ In addition to the requirements for [building Filament on Windows](../BUILDING.m
 need the Android SDK and NDK. See [Getting Started with the
 NDK](https://developer.android.com/ndk/guides/) for detailed installation instructions.
 
+You'll also need [Ninja 1.8](https://github.com/ninja-build/ninja/wiki/Pre-built-Ninja-packages) (or
+more recent) and [Git for Windows](https://git-scm.com/download/win) to clone the repository and run
+Bash scripts.
+
 Ensure the `%ANDROID_HOME%` environment variable is set to your Android SDK installation location.
 
 On Windows, we require VS2019 for building the host tools. All of the following commands should be
 executed in a *Visual Studio x64 Native Tools Command Prompt for VS 2019*.
 
+### A Note About Python 3
+
+Python 3 is required. If CMake errors because it cannot find Python 3:
+
+```
+Could NOT find PythonInterp: Found unsuitable version "1.4", but required is at least "3"
+```
+
+then add the following flag to the CMake invocations:
+
+```
+-DPYTHON_EXECUTABLE:FILEPATH=\path\to\python3
+```
+
 ## Desktop Tools
 
 First, a few Filament tools need to be compiled for desktop.
@@ -104,20 +122,20 @@ The Gradle project used to generate the AAR is located at `<filament>\android`.
 
 ```
 cd android
-gradlew -Pfilament_dist_dir=..\out\android-release\filament assembleRelease
+gradlew -Pcom.google.android.filament.dist-dir=..\out\android-release\filament assembleRelease
 copy filament-android\build\outputs\aar\filament-android-release.aar ..\..\out\
 ```
 
-If you're only interested in building for a single ABI, you'll need to pass a `filament_abis` parameter:
+If you're only interested in building for a single ABI, you'll need to pass a `com.google.android.filament.abis` parameter:
 
 ```
-gradlew -Pfilament_dist_dir=..\out\android-release\filament assembleRelease -Pfilament_abis=x86
+gradlew -Pcom.google.android.filament.dist-dir=..\out\android-release\filament assembleRelease -Pcom.google.android.filament.abis=x86
 ```
 
-If you're only interested in building SDK, you may skip samples build by passing a `filament_skip_samples` flag:
+If you're only interested in building SDK, you may skip samples build by passing a `com.google.android.filament.skip-samples` flag:
 
 ```
-gradlew -Pfilament_dist_dir=..\out\android-release\filament assembleRelease -Pfilament_skip_samples
+gradlew -Pcom.google.android.filament.dist-dir=..\out\android-release\filament assembleRelease -Pfilament_skip_samples
 ```
 
 

android/build.gradle

@@ -1,67 +1,99 @@
 // This script accepts the following parameters:
 //
-// filament_dist_dir
+// com.google.android.filament.dist-dir
 //     Path to the Filament distribution/install directory for Android
 //     (produced by make/ninja install). This directory must contain lib/arm64-v8a/ etc.
 //
-// filament_tools_dir
+// com.google.android.filament.tools-dir
 //     Path to the Filament distribution/install directory for desktop.
 //     This directory must contain bin/matc.
 //
-// filament_exclude_vulkan
+// com.google.android.filament.exclude-vulkan
 //     When set, support for Vulkan will be excluded.
 //
-// filament_skip_samples
+// com.google.android.filament.skip-samples
 //     Exclude samples from the project. Useful to speed up compilation.
 //
-// filament_abis
+// com.google.android.filament.abis
 //     List of supported ABIs to build as a comma separated list. Available options are:
 //         arm64-v8a, armeabi-v7a, x86_64, x86, all
 //     Defaults to all.
 //
 // Example:
-//     ./gradlew -Pfilament_dist_dir=../dist-android-release assembleRelease -Pfilament_abis=x86
+//     ./gradlew -Pcom.google.android.filament.dist-dir=../dist-android-release \
+//               -Pcom.google.android.filament.abis=x86 \
+//               assembleRelease
+
+// Publishing to Maven Central:
+//   - Build and upload artifacts with ./gradlew publish
+//   - Close and release staging repo on Nexus with ./gradlew closeAndReleaseRepository
+//
+// The following is needed in ~/gradle/gradle.properties:
+//
+//     SONATYPE_NEXUS_USERNAME=nexus_user
+//     SONATYPE_NEXUS_PASSWORD=nexus_password
+//
+//     nexusUsername=nexus_user
+//     nexusPassword=nexus_password
+//
+//     signing.keyId=pgp_key_id
+//     signing.password=pgp_key_password
+//     signing.secretKeyRingFile=/Users/user/.gnupg/maven_signing.key
+//
 
 buildscript {
-    def filamentPath = file("../out/android-release/filament").absolutePath
-    if (project.hasProperty("filament_dist_dir")) {
-        filamentPath = file(project.property("filament_dist_dir")).absolutePath
-    }
+    def path = providers
+            .gradleProperty("com.google.android.filament.dist-dir")
+            .forUseAtConfigurationTime().get()
+
+    def directory = objects.fileProperty().fileValue(new File(path)).getAsFile().get()
+    def filamentPath = directory.absolutePath
+
     // Our CMake scripts require a forward-slash path for the FILAMENT_DIST_DIR
     // variable, so here we convert the native path to a forward-slash path.
     filamentPath = filamentPath.replace(File.separator, '/')
 
     // Warning: changing this property does not work well with incremental builds.
-    def excludeVulkan = project.hasProperty("filament_exclude_vulkan")
+    def excludeVulkan = providers
+            .gradleProperty("com.google.android.filament.exclude-vulkan")
+            .forUseAtConfigurationTime()
+            .isPresent()
 
     def abis = ["arm64-v8a", "armeabi-v7a", "x86_64", "x86"]
-    if (project.hasProperty("filament_abis")) {
-        def newAbis = project.property("filament_abis").split(',')
-        if (!newAbis.contains("all")) {
-            abis = newAbis
-        }
+    def newAbis = providers
+            .gradleProperty("com.google.android.filament.abis")
+            .forUseAtConfigurationTime()
+            .get()
+            .split(',')
+    if (!newAbis.contains("all")) {
+        abis = newAbis
     }
 
-    // Our minSdkVersion is 19.
     ext.versions = [
         'minSdk': 19,
-        'targetSdk': 29,
-        'compileSdk': 29,
-        'kotlin': '1.3.72',
-        'buildTools': '30.0.1',
-        'ndk': '21.3.6528147'
+        'targetSdk': 31,
+        'compileSdk': 31,
+        'kotlin': '1.6.0',
+        'kotlin_coroutines': '1.5.2',
+        'buildTools': '31.0.0',
+        'ndk': '23.1.7779620'
     ]
 
     ext.deps = [
         'androidx': [
-            'annotations': "androidx.annotation:annotation:1.1.0",
-            'core': "androidx.core:core:1.3.0",
+            'annotations': "androidx.annotation:annotation:1.3.0",
+            'core': "androidx.core:core:1.7.0",
         ],
-        'kotlin': "org.jetbrains.kotlin:kotlin-stdlib-jdk8:${versions.kotlin}"
+        'kotlin': "org.jetbrains.kotlin:kotlin-stdlib-jdk8:${versions.kotlin}",
+        'coroutines': [
+            'core': "org.jetbrains.kotlinx:kotlinx-coroutines-core:${versions.kotlin_coroutines}",
+            'android': "org.jetbrains.kotlinx:kotlinx-coroutines-android:${versions.kotlin_coroutines}",
+        ]
     ]
 
     dependencies {
-        classpath 'com.android.tools.build:gradle:4.0.1'
+        // NOTE: See TODO in gradle.properties once we move to Gradle 7.2
+        classpath 'com.android.tools.build:gradle:7.0.3'
         classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${versions.kotlin}"
     }
 
@@ -76,8 +108,7 @@ buildscript {
     ext.cppFlags = [
         "-std=c++17",
         "-Wno-unused-command-line-argument",
-        // Required to support API levels below 23
-        "-Wl,--hash-style=both",
+        "-Wl,--hash-style=both", // Required to support API levels below 23
         "-fno-stack-protector",
         "-fno-exceptions",
         "-fno-unwind-tables",
@@ -99,10 +130,20 @@ buildscript {
     repositories {
         mavenCentral()
         google()
-        jcenter()
     }
 }
 
+plugins {
+    id 'io.codearte.nexus-staging' version '0.30.0'
+}
+
+// Nexus Staging configuration
+// See https://github.com/Codearte/gradle-nexus-staging-plugin/
+nexusStaging {
+    packageGroup = 'com.google.android'
+    stagingProfileId = '9a75a224a4f17b'
+}
+
 subprojects {
     group = GROUP
     version = VERSION_NAME
@@ -110,7 +151,6 @@ subprojects {
     repositories {
         mavenCentral()
         google()
-        jcenter()
     }
 
     if (!name.startsWith("sample")) {
@@ -135,11 +175,13 @@ subprojects {
                 ndk {
                     abiFilters(*rootProject.ext.abis)
                 }
-            }
 
+                consumerProguardFiles '../proguard-rules.pro'
+            }
 
             externalNativeBuild {
                 cmake {
+                    version "3.19.0+"
                     path "CMakeLists.txt"
                 }
             }
@@ -161,7 +203,8 @@ subprojects {
 gradle.taskGraph.whenReady {
     gradle.taskGraph.allTasks.each {
         it.onlyIf {
-            !it.project.ext.has('isSample') || !project.hasProperty('filament_skip_samples')
+            !it.project.ext.has('isSample') ||
+                    !project.hasProperty('com.google.android.filament.skip-samples')
          }
     }
 }

android/buildSrc/build.gradle

@@ -1,3 +1,17 @@
+
+plugins {
+    id 'groovy-gradle-plugin'
+}
+
+gradlePlugin {
+    plugins {
+        create("filament-tools-plugin") {
+            id = "filament-tools-plugin"
+            implementationClass = "FilamentToolsPlugin"
+        }
+    }
+}
+
 repositories {
     mavenCentral()
 }

android/buildSrc/src/main/groovy/FilamentPlugin.groovy

@@ -1,56 +1,72 @@
 // This plugin accepts the following parameters:
 //
-// filament_tools_dir
+// com.google.android.filament.tools-dir
 //     Path to the Filament distribution/install directory for desktop.
 //     This directory must contain bin/matc.
 //
-// filament_exclude_vulkan
+// com.google.android.filament.exclude-vulkan
 //     When set, support for Vulkan will be excluded.
 //
 // Example:
-//     ./gradlew -Pfilament_tools_dir=../../dist-release assembleDebug
+//     ./gradlew -Pcom.google.android.filament.tools-dir=../../dist-release assembleDebug
 
 import org.gradle.api.DefaultTask
 import org.gradle.api.GradleException
 import org.gradle.api.Plugin
 import org.gradle.api.Project
+import org.gradle.api.provider.ProviderFactory
 import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.file.FileSystemOperations
 import org.gradle.api.file.FileType
 import org.gradle.api.file.RegularFileProperty
 import org.gradle.api.logging.LogLevel
 import org.gradle.api.logging.Logger
+import org.gradle.api.provider.Property
+import org.gradle.api.tasks.Input
 import org.gradle.api.tasks.InputDirectory
 import org.gradle.api.tasks.InputFile
+import org.gradle.api.tasks.Optional
 import org.gradle.api.tasks.OutputDirectory
 import org.gradle.api.tasks.TaskAction
 import org.gradle.api.tasks.incremental.InputFileDetails
+import org.gradle.api.model.ObjectFactory
 import org.gradle.internal.os.OperatingSystem
+import org.gradle.process.ExecOperations
 import org.gradle.work.ChangeType
 import org.gradle.work.Incremental
 import org.gradle.work.InputChanges
 
 import java.nio.file.Paths
 
-class TaskWithBinary extends DefaultTask {
+import javax.inject.Inject
+
+abstract class TaskWithBinary extends DefaultTask {
     private final String binaryName
-    private File binaryPath = null
+    private Property<String> binaryPath = null
 
     TaskWithBinary(String name) {
         binaryName = name
     }
 
-    String getBinaryName() {
-        return binaryName
-    }
+    @Inject abstract ObjectFactory getObjects()
+    @Inject abstract ProviderFactory getProviders()
 
-    File getBinary() {
+    @Input
+    Property<String> getBinary() {
         if (binaryPath == null) {
             def tool = ["/bin/${binaryName}.exe", "/bin/${binaryName}"]
             def fullPath = tool.collect { path ->
-                Paths.get(project.ext.filamentToolsPath.absolutePath, path).toFile()
+                def filamentToolsPath = providers
+                        .gradleProperty("com.google.android.filament.tools-dir")
+                        .forUseAtConfigurationTime().get()
+                def directory = objects.fileProperty()
+                        .fileValue(new File(filamentToolsPath)).getAsFile().get()
+                Paths.get(directory.absolutePath, path).toFile()
             }
 
-            binaryPath = OperatingSystem.current().isWindows() ? fullPath[0] : fullPath[1]
+            binaryPath = objects.property(String.class)
+            binaryPath.set(
+                    (OperatingSystem.current().isWindows() ? fullPath[0] : fullPath[1]).toString())
         }
         return binaryPath
     }
@@ -65,14 +81,6 @@ class LogOutputStream extends ByteArrayOutputStream {
         this.level = level
     }
 
-    Logger getLogger() {
-        return logger
-    }
-
-    LogLevel getLevel() {
-        return level
-    }
-
     @Override
     void flush() {
         logger.log(level, toString())
@@ -85,10 +93,15 @@ class LogOutputStream extends ByteArrayOutputStream {
 abstract class MaterialCompiler extends TaskWithBinary {
     @Incremental
     @InputDirectory
-    final DirectoryProperty inputDir = project.objects.directoryProperty()
+    abstract DirectoryProperty getInputDir()
 
     @OutputDirectory
-    final DirectoryProperty outputDir = project.objects.directoryProperty()
+    abstract DirectoryProperty getOutputDir()
+
+    @Inject abstract FileSystemOperations getFs()
+    @Inject abstract ExecOperations getExec()
+    @Inject abstract ObjectFactory getObjects()
+    @Inject abstract ProviderFactory getProviders()
 
     MaterialCompiler() {
         super("matc")
@@ -97,7 +110,9 @@ abstract class MaterialCompiler extends TaskWithBinary {
     @TaskAction
     void execute(InputChanges inputs) {
         if (!inputs.incremental) {
-            project.delete(project.fileTree(outputDir.asFile.get()).matching { include '*.filamat' })
+            fs.delete({
+                delete(objects.fileTree().from(outputDir).matching { include '*.filamat' })
+            })
         }
 
         inputs.getFileChanges(inputDir).each { InputFileDetails change ->
@@ -115,21 +130,24 @@ abstract class MaterialCompiler extends TaskWithBinary {
                 out.write(header)
                 out.flush()
 
-                if (!getBinary().exists()) {
-                    throw new GradleException("Could not find ${getBinary()}." +
+                if (!new File(binary.get()).exists()) {
+                    throw new GradleException("Could not find ${binary.get()}." +
                             " Ensure Filament has been built/installed before building this app.")
                 }
 
                 def matcArgs = []
-                if (!project.hasProperty("filament_exclude_vulkan")) {
+                def exclude_vulkan = providers
+                        .gradleProperty("com.google.android.filament.exclude-vulkan")
+                        .forUseAtConfigurationTime().present
+                if (!exclude_vulkan) {
                     matcArgs += ['-a', 'vulkan']
                 }
                 matcArgs += ['-a', 'opengl', '-p', 'mobile', '-o', getOutputFile(file), file]
 
-                project.exec {
+                exec.exec {
                     standardOutput out
                     errorOutput err
-                    executable "${getBinary()}"
+                    executable "${binary.get()}"
                     args matcArgs
                 }
             }
@@ -143,15 +161,21 @@ abstract class MaterialCompiler extends TaskWithBinary {
 
 // Custom task to process IBLs using cmgen
 // This task handles incremental builds
-class IblGenerator extends TaskWithBinary {
-    String cmgenArgs = null
+abstract class IblGenerator extends TaskWithBinary {
+    @Input
+    @Optional
+    abstract Property<String> getCmgenArgs()
 
     @Incremental
     @InputFile
-    final RegularFileProperty inputFile = project.objects.fileProperty()
+    abstract RegularFileProperty getInputFile()
 
     @OutputDirectory
-    final DirectoryProperty outputDir = project.objects.directoryProperty()
+    abstract DirectoryProperty getOutputDir()
+
+    @Inject abstract FileSystemOperations getFs()
+    @Inject abstract ExecOperations getExec()
+    @Inject abstract ObjectFactory getObjects()
 
     IblGenerator() {
         super("cmgen")
@@ -160,7 +184,9 @@ class IblGenerator extends TaskWithBinary {
     @TaskAction
     void execute(InputChanges inputs) {
         if (!inputs.incremental) {
-            project.delete(project.fileTree(outputDir.asFile.get()).matching { include '*' })
+            fs.delete({
+                delete(objects.fileTree().from(outputDir).matching { include '*' })
+            })
         }
 
         inputs.getFileChanges(inputFile).each { InputFileDetails change ->
@@ -178,23 +204,25 @@ class IblGenerator extends TaskWithBinary {
                 out.write(header)
                 out.flush()
 
-                if (!getBinary().exists()) {
-                    throw new GradleException("Could not find ${getBinary()}." +
+                if (!new File(binary.get()).exists()) {
+                    throw new GradleException("Could not find ${binary.get()}." +
                             " Ensure Filament has been built/installed before building this app.")
                 }
 
                 def outputPath = outputDir.get().asFile
-                project.exec {
+                def commandArgs = cmgenArgs.getOrNull()
+                if (commandArgs == null) {
+                    commandArgs =
+                            '-q -x ' + outputPath + ' --format=rgb32f ' +
+                                    '--extract-blur=0.08 --extract=' + outputPath.absolutePath
+                }
+                commandArgs = commandArgs + " " + file
+
+                exec.exec {
                     standardOutput out
-                    if (!cmgenArgs) {
-                        cmgenArgs =
-                                '-q -x ' + outputPath + ' --format=rgb32f ' +
-                                '--extract-blur=0.08 --extract=' + outputPath.absolutePath
-                    }
-                    cmgenArgs = cmgenArgs + " " + file
                     errorOutput err
-                    executable "${getBinary()}"
-                    args(cmgenArgs.split())
+                    executable "${binary.get()}"
+                    args(commandArgs.split())
                 }
             }
         }
@@ -207,13 +235,16 @@ class IblGenerator extends TaskWithBinary {
 
 // Custom task to compile mesh files using filamesh
 // This task handles incremental builds
-class MeshCompiler extends TaskWithBinary {
+abstract class MeshCompiler extends TaskWithBinary {
     @Incremental
     @InputFile
-    final RegularFileProperty inputFile = project.objects.fileProperty()
+    abstract RegularFileProperty getInputFile()
 
     @OutputDirectory
-    final DirectoryProperty outputDir = project.objects.directoryProperty()
+    abstract DirectoryProperty getOutputDir()
+
+    @Inject abstract FileSystemOperations getFs()
+    @Inject abstract ExecOperations getExec()
 
     MeshCompiler() {
         super("filamesh")
@@ -222,7 +253,9 @@ class MeshCompiler extends TaskWithBinary {
     @TaskAction
     void execute(InputChanges inputs) {
         if (!inputs.incremental) {
-            project.delete(project.fileTree(outputDir.asFile.get()).matching { include '*.filamesh' })
+            fs.delete({
+                delete(objects.fileTree().from(outputDir).matching { include '*.filamesh' })
+            })
         }
 
         inputs.getFileChanges(inputFile).each { InputFileDetails change ->
@@ -240,15 +273,15 @@ class MeshCompiler extends TaskWithBinary {
                 out.write(header)
                 out.flush()
 
-                if (!getBinary().exists()) {
-                    throw new GradleException("Could not find ${getBinary()}." +
+                if (!new File(binary.get()).exists()) {
+                    throw new GradleException("Could not find ${binary.get()}." +
                             " Ensure Filament has been built/installed before building this app.")
                 }
 
-                project.exec {
+                exec.exec {
                     standardOutput out
                     errorOutput err
-                    executable "${getBinary()}"
+                    executable "${binary.get()}"
                     args(file, getOutputFile(file))
                 }
             }
@@ -282,17 +315,12 @@ class FilamentToolsPlugin implements Plugin<Project> {
         extension.meshInputFile = project.objects.fileProperty()
         extension.meshOutputDir = project.objects.directoryProperty()
 
-        project.ext.filamentToolsPath = project.file("../../../out/release/filament")
-        if (project.hasProperty("filament_tools_dir")) {
-            project.ext.filamentToolsPath = project.file(project.property("filament_tools_dir"))
-        }
-
         project.tasks.register("filamentCompileMaterials", MaterialCompiler) {
             enabled =
                     extension.materialInputDir.isPresent() &&
                     extension.materialOutputDir.isPresent()
-            inputDir = extension.materialInputDir.getOrNull()
-            outputDir = extension.materialOutputDir.getOrNull()
+            inputDir.set(extension.materialInputDir.getOrNull())
+            outputDir.set(extension.materialOutputDir.getOrNull())
         }
 
         project.preBuild.dependsOn "filamentCompileMaterials"

android/common/CallbackUtils.cpp

@@ -16,8 +16,10 @@
 
 #include "CallbackUtils.h"
 
+#include "private/backend/VirtualMachineEnv.h"
+
 void acquireCallbackJni(JNIEnv* env, CallbackJni& callbackUtils) {
-#ifdef ANDROID
+#ifdef __ANDROID__
     callbackUtils.handlerClass = env->FindClass("android/os/Handler");
     callbackUtils.handlerClass = (jclass) env->NewGlobalRef(callbackUtils.handlerClass);
     callbackUtils.post = env->GetMethodID(callbackUtils.handlerClass,
@@ -32,7 +34,7 @@ void acquireCallbackJni(JNIEnv* env, CallbackJni& callbackUtils) {
 
 void releaseCallbackJni(JNIEnv* env, CallbackJni callbackUtils, jobject handler, jobject callback) {
     if (handler && callback) {
-#ifdef ANDROID
+#ifdef __ANDROID__
         if (env->IsInstanceOf(handler, callbackUtils.handlerClass)) {
             env->CallBooleanMethod(handler, callbackUtils.post, callback);
         }
@@ -43,55 +45,76 @@ void releaseCallbackJni(JNIEnv* env, CallbackJni callbackUtils, jobject handler,
     }
     env->DeleteGlobalRef(handler);
     env->DeleteGlobalRef(callback);
-#ifdef ANDROID
+#ifdef __ANDROID__
     env->DeleteGlobalRef(callbackUtils.handlerClass);
 #endif
     env->DeleteGlobalRef(callbackUtils.executorClass);
 }
 
-JniBufferCallback* JniBufferCallback::make(filament::Engine* engine,
+// -----------------------------------------------------------------------------------------------
+
+JniCallback* JniCallback::make(JNIEnv* env, jobject handler, jobject callback) {
+    return new JniCallback(env, handler, callback);
+}
+
+JniCallback::JniCallback(JNIEnv* env, jobject handler, jobject callback)
+        : mHandler(env->NewGlobalRef(handler)),
+          mCallback(env->NewGlobalRef(callback)) {
+    acquireCallbackJni(env, mCallbackUtils);
+}
+
+JniCallback::~JniCallback() = default;
+
+void JniCallback::post(void* user, filament::backend::CallbackHandler::Callback callback) {
+    callback(user);
+}
+
+void JniCallback::postToJavaAndDestroy(JniCallback* callback) {
+    JNIEnv* env = filament::VirtualMachineEnv::get().getEnvironment();
+    releaseCallbackJni(env, callback->mCallbackUtils, callback->mHandler, callback->mCallback);
+    delete callback;
+}
+
+// -----------------------------------------------------------------------------------------------
+
+JniBufferCallback* JniBufferCallback::make(filament::Engine*,
         JNIEnv* env, jobject handler, jobject callback, AutoBuffer&& buffer) {
     return new JniBufferCallback(env, handler, callback, std::move(buffer));
 }
 
 JniBufferCallback::JniBufferCallback(JNIEnv* env, jobject handler, jobject callback,
         AutoBuffer&& buffer)
-        : mEnv(env)
-        , mHandler(env->NewGlobalRef(handler))
-        , mCallback(env->NewGlobalRef(callback))
-        , mBuffer(std::move(buffer)) {
-    acquireCallbackJni(env, mCallbackUtils);
+        : JniCallback(env, handler, callback),
+        mBuffer(std::move(buffer)) {
 }
 
-JniBufferCallback::~JniBufferCallback() {
-    releaseCallbackJni(mEnv, mCallbackUtils, mHandler, mCallback);
-}
+JniBufferCallback::~JniBufferCallback() = default;
 
-void JniBufferCallback::invoke(void*, size_t, void* user) {
-    JniBufferCallback* data = reinterpret_cast<JniBufferCallback*>(user);
-    delete data;
+void JniBufferCallback::postToJavaAndDestroy(void*, size_t, void* user) {
+    JniBufferCallback* callback = (JniBufferCallback*)user;
+    JNIEnv* env = filament::VirtualMachineEnv::get().getEnvironment();
+    callback->mBuffer.attachToJniThread(env);
+    releaseCallbackJni(env, callback->mCallbackUtils, callback->mHandler, callback->mCallback);
+    delete callback;
 }
 
 // -----------------------------------------------------------------------------------------------
 
-JniImageCallback* JniImageCallback::make(filament::Engine* engine,
+JniImageCallback* JniImageCallback::make(filament::Engine*,
         JNIEnv* env, jobject handler, jobject callback, long image) {
     return new JniImageCallback(env, handler, callback, image);
 }
 
 JniImageCallback::JniImageCallback(JNIEnv* env, jobject handler, jobject callback, long image)
-        : mEnv(env)
-        , mHandler(env->NewGlobalRef(handler))
-        , mCallback(env->NewGlobalRef(callback))
-        , mImage(image) {
-    acquireCallbackJni(env, mCallbackUtils);
+        : JniCallback(env, handler, callback),
+        mImage(image) {
 }
 
-JniImageCallback::~JniImageCallback() {
-    releaseCallbackJni(mEnv, mCallbackUtils, mHandler, mCallback);
-}
+JniImageCallback::~JniImageCallback() = default;
 
-void JniImageCallback::invoke(void*, void* user) {
-    JniImageCallback* data = reinterpret_cast<JniImageCallback*>(user);
-    delete data;
+void JniImageCallback::postToJavaAndDestroy(void*, void* user) {
+    JniImageCallback* callback = (JniImageCallback*)user;
+    JNIEnv* env = filament::VirtualMachineEnv::get().getEnvironment();
+    releaseCallbackJni(env, callback->mCallbackUtils, callback->mHandler, callback->mCallback);
+    delete callback;
 }

android/common/CallbackUtils.h

@@ -18,57 +18,78 @@
 
 #include <jni.h>
 
-#include "common/CallbackUtils.h"
 #include "common/NioUtils.h"
 
+#include <backend/CallbackHandler.h>
+
 #include <filament/Engine.h>
 
 struct CallbackJni {
-#ifdef ANDROID
-    jclass handlerClass;
-    jmethodID post;
+#ifdef __ANDROID__
+    jclass handlerClass = nullptr;
+    jmethodID post = nullptr;
 #endif
-    jclass executorClass;
-    jmethodID execute;
+    jclass executorClass = nullptr;
+    jmethodID execute = nullptr;
 };
 
 void acquireCallbackJni(JNIEnv* env, CallbackJni& callbackUtils);
 void releaseCallbackJni(JNIEnv* env, CallbackJni callbackUtils, jobject handler, jobject callback);
 
-struct JniBufferCallback {
+struct JniCallback : private filament::backend::CallbackHandler {
+    JniCallback(JniCallback const &) = delete;
+    JniCallback(JniCallback&&) = delete;
+    JniCallback& operator=(JniCallback const &) = delete;
+    JniCallback& operator=(JniCallback&&) = delete;
+
+    // create a JniCallback
+    static JniCallback* make(JNIEnv* env, jobject handler, jobject runnable);
+
+    // execute the callback on the java thread and destroy ourselves
+    static void postToJavaAndDestroy(JniCallback* callback);
+
+    // CallbackHandler interface.
+    void post(void* user, Callback callback) override;
+
+    // Get the CallbackHandler interface
+    filament::backend::CallbackHandler* getHandler() noexcept { return this; }
+
+    jobject getCallbackObject() { return mCallback; }
+
+protected:
+    JniCallback(JNIEnv* env, jobject handler, jobject runnable);
+    explicit JniCallback() = default; // this version does nothing
+    virtual ~JniCallback();
+    jobject mHandler{};
+    jobject mCallback{};
+    CallbackJni mCallbackUtils{};
+};
+
+
+struct JniBufferCallback : public JniCallback {
+    // create a JniBufferCallback
     static JniBufferCallback* make(filament::Engine* engine,
             JNIEnv* env, jobject handler, jobject callback, AutoBuffer&& buffer);
 
-    static void invoke(void* buffer, size_t n, void* user);
+    // execute the callback on the java thread and destroy ourselves
+    static void postToJavaAndDestroy(void*, size_t, void* user);
 
 private:
     JniBufferCallback(JNIEnv* env, jobject handler, jobject callback, AutoBuffer&& buffer);
-    JniBufferCallback(JniBufferCallback const &) = delete;
-    JniBufferCallback(JniBufferCallback&&) = delete;
-    ~JniBufferCallback();
-
-    JNIEnv* mEnv;
-    jobject mHandler;
-    jobject mCallback;
+    virtual ~JniBufferCallback();
     AutoBuffer mBuffer;
-    CallbackJni mCallbackUtils;
 };
 
-struct JniImageCallback {
+struct JniImageCallback : public JniCallback {
+    // create a JniImageCallback
     static JniImageCallback* make(filament::Engine* engine, JNIEnv* env, jobject handler,
             jobject runnable, long image);
 
-    static void invoke(void* image, void* user);
+    // execute the callback on the java thread and destroy ourselves
+    static void postToJavaAndDestroy(void*, void* user);
 
 private:
     JniImageCallback(JNIEnv* env, jobject handler, jobject runnable, long image);
-    JniImageCallback(JniBufferCallback const &) = delete;
-    JniImageCallback(JniBufferCallback&&) = delete;
-    ~JniImageCallback();
-
-    JNIEnv* mEnv;
-    jobject mHandler;
-    jobject mCallback;
+    virtual ~JniImageCallback();
     long mImage;
-    CallbackJni mCallbackUtils;
 };

android/common/NioUtils.h

@@ -38,6 +38,10 @@ public:
     AutoBuffer(AutoBuffer&& rhs) noexcept;
     ~AutoBuffer() noexcept;
 
+    void attachToJniThread(JNIEnv* env) noexcept {
+        mEnv = env;
+    }
+
     void* getData() const noexcept {
         return mUserData;
     }

android/filamat-android/CMakeLists.txt

@@ -1,4 +1,5 @@
-cmake_minimum_required(VERSION 3.6)
+cmake_minimum_required(VERSION 3.19)
+project(filamat-android)
 
 option(FILAMENT_ENABLE_MATDBG "Enables Material debugger" OFF)
 
@@ -33,13 +34,16 @@ add_library(shaders STATIC IMPORTED)
 set_target_properties(shaders PROPERTIES IMPORTED_LOCATION
         ${FILAMENT_DIR}/lib/${ANDROID_ABI}/libshaders.a)
 
+set(FILAMAT_INCLUDE_DIRS
+        ../../libs/utils/include
+        )
+
 include_directories(${FILAMENT_DIR}/include)
 
 set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} -Wl,--version-script=${CMAKE_SOURCE_DIR}/libfilamat-jni.map")
 
-add_library(filamat-jni SHARED
-        src/main/cpp/MaterialBuilder.cpp
-)
+add_library(filamat-jni SHARED src/main/cpp/MaterialBuilder.cpp)
+target_include_directories(filamat-jni PRIVATE ${FILAMAT_INCLUDE_DIRS})
 
 target_link_libraries(filamat-jni
         ${FILAMAT_FLAVOR}

android/filamat-android/src/main/cpp/MaterialBuilder.cpp

@@ -18,6 +18,8 @@
 
 #include <filamat/MaterialBuilder.h>
 
+#include <utils/JobSystem.h>
+
 using namespace filament;
 using namespace filamat;
 
@@ -45,9 +47,23 @@ Java_com_google_android_filament_filamat_MaterialBuilder_nDestroyMaterialBuilder
 
 extern "C" JNIEXPORT jlong JNICALL
 Java_com_google_android_filament_filamat_MaterialBuilder_nBuilderBuild(JNIEnv*, jclass,
-        jlong nativeBuilder) {
+        jlong nativeBuilder, jlong nativeJobSystem) {
     auto builder = (MaterialBuilder*) nativeBuilder;
-    return (jlong) new Package(builder->build());
+    auto jobSystem = (utils::JobSystem*) nativeJobSystem;
+
+    if (nativeJobSystem == 0) {
+        jobSystem = new utils::JobSystem;
+        jobSystem->adopt();
+    }
+
+    jlong result = (jlong) new Package(builder->build(*jobSystem));
+
+    if (nativeJobSystem == 0) {
+        jobSystem->emancipate();
+        delete jobSystem;
+    }
+
+    return result;
 }
 
 extern "C" JNIEXPORT jbyteArray JNICALL
@@ -107,19 +123,22 @@ Java_com_google_android_filament_filamat_MaterialBuilder_nMaterialBuilderInterpo
 
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_filamat_MaterialBuilder_nMaterialBuilderUniformParameter(
-        JNIEnv* env, jclass, jlong nativeBuilder, jint uniformType, jstring name_) {
+        JNIEnv* env, jclass, jlong nativeBuilder, jint uniformType, jint precision, jstring name_) {
     auto builder = (MaterialBuilder*) nativeBuilder;
     const char* name = env->GetStringUTFChars(name_, nullptr);
-    builder->parameter((MaterialBuilder::UniformType) uniformType, name);
+    builder->parameter((MaterialBuilder::UniformType) uniformType,
+            (MaterialBuilder::ParameterPrecision) precision, name);
     env->ReleaseStringUTFChars(name_, name);
 }
 
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_filamat_MaterialBuilder_nMaterialBuilderUniformParameterArray(
-        JNIEnv* env, jclass, jlong nativeBuilder, jint uniformType, jint size, jstring name_) {
+        JNIEnv* env, jclass, jlong nativeBuilder, jint uniformType, jint size, jint precision,
+        jstring name_) {
     auto builder = (MaterialBuilder*) nativeBuilder;
     const char* name = env->GetStringUTFChars(name_, nullptr);
-    builder->parameter((MaterialBuilder::UniformType) uniformType, (size_t) size, name);
+    builder->parameter((MaterialBuilder::UniformType) uniformType, (size_t) size,
+            (MaterialBuilder::ParameterPrecision) precision, name);
     env->ReleaseStringUTFChars(name_, name);
 }
 
@@ -130,7 +149,7 @@ Java_com_google_android_filament_filamat_MaterialBuilder_nMaterialBuilderSampler
     auto builder = (MaterialBuilder*) nativeBuilder;
     const char* name = env->GetStringUTFChars(name_, nullptr);
     builder->parameter((MaterialBuilder::SamplerType) samplerType,
-            (MaterialBuilder::SamplerFormat) format, (MaterialBuilder::SamplerPrecision) precision,
+            (MaterialBuilder::SamplerFormat) format, (MaterialBuilder::ParameterPrecision) precision,
             name);
     env->ReleaseStringUTFChars(name_, name);
 }
@@ -239,6 +258,13 @@ Java_com_google_android_filament_filamat_MaterialBuilder_nMaterialBuilderShadowM
     builder->shadowMultiplier(shadowMultiplier);
 }
 
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_filamat_MaterialBuilder_nMaterialBuilderTransparentShadow(
+        JNIEnv*, jclass, jlong nativeBuilder, jboolean transparentShadow) {
+    auto builder = (MaterialBuilder*) nativeBuilder;
+    builder->transparentShadow(transparentShadow);
+}
+
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_filamat_MaterialBuilder_nMaterialBuilderSpecularAntiAliasing(
         JNIEnv*, jclass, jlong nativeBuilder, jboolean specularAntiAliasing) {
@@ -275,6 +301,13 @@ Java_com_google_android_filament_filamat_MaterialBuilder_nMaterialBuilderFlipUV(
     builder->flipUV(flipUV);
 }
 
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_filamat_MaterialBuilder_nMaterialBuilderCustomSurfaceShading(JNIEnv*,
+        jclass, jlong nativeBuilder, jboolean customSurfaceShading) {
+    auto builder = (MaterialBuilder*) nativeBuilder;
+    builder->customSurfaceShading(customSurfaceShading);
+}
+
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_filamat_MaterialBuilder_nMaterialBuilderMultiBounceAmbientOcclusion(
         JNIEnv*, jclass, jlong nativeBuilder, jboolean multiBounceAO) {

android/filamat-android/src/main/java/com/google/android/filament/filamat/MaterialBuilder.java

@@ -17,17 +17,29 @@
 package com.google.android.filament.filamat;
 
 import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
 import java.nio.ByteBuffer;
 
 public class MaterialBuilder {
-
     @SuppressWarnings({"FieldCanBeLocal", "UnusedDeclaration"})
     // Keep to finalize native resources
     private final BuilderFinalizer mFinalizer;
     private final long mNativeObject;
 
+    private static Class<?> sEngineClass = null;
+    private static Method sGetNativeJobSystemMethod = null;
+
     static {
         System.loadLibrary("filamat-jni");
+        try {
+            sEngineClass = Class.forName("com.google.android.filament.Engine");
+            sGetNativeJobSystemMethod = sEngineClass.getDeclaredMethod("getNativeJobSystem");
+        } catch (ClassNotFoundException | NoSuchMethodException e) {
+            // It's okay if we don't find it, this is to avoid creating dependencies
+        }
     }
 
     public enum Shading {
@@ -79,7 +91,7 @@ public class MaterialBuilder {
         SHADOW
     }
 
-    public enum SamplerPrecision {
+    public enum ParameterPrecision {
         LOW,
         MEDIUM,
         HIGH,
@@ -102,14 +114,14 @@ public class MaterialBuilder {
         BONE_INDICES,           // indices of 4 bones (uvec4)
         BONE_WEIGHTS,           // weights of the 4 bones (normalized float4)
         UNUSED,                 // reserved for future use
-        CUSTOM0,                // custom or MORPH_POSITION_0
-        CUSTOM1,                // custom or MORPH_POSITION_1
-        CUSTOM2,                // custom or MORPH_POSITION_2
-        CUSTOM3,                // custom or MORPH_POSITION_3
-        CUSTOM4,                // custom or MORPH_TANGENTS_0
-        CUSTOM5,                // custom or MORPH_TANGENTS_1
-        CUSTOM6,                // custom or MORPH_TANGENTS_2
-        CUSTOM7                 // custom or MORPH_TANGENTS_3
+        CUSTOM0,                // custom
+        CUSTOM1,                // custom
+        CUSTOM2,                // custom
+        CUSTOM3,                // custom
+        CUSTOM4,                // custom
+        CUSTOM5,                // custom
+        CUSTOM6,                // custom
+        CUSTOM7                 // custom
     }
 
     public enum BlendingMode {
@@ -235,19 +247,36 @@ public class MaterialBuilder {
 
     @NonNull
     public MaterialBuilder uniformParameter(@NonNull UniformType type, String name) {
-        nMaterialBuilderUniformParameter(mNativeObject, type.ordinal(), name);
+        nMaterialBuilderUniformParameter(mNativeObject, type.ordinal(),
+                ParameterPrecision.DEFAULT.ordinal(), name);
+        return this;
+    }
+
+    @NonNull
+    public MaterialBuilder uniformParameter(@NonNull UniformType type,
+            ParameterPrecision precision, String name) {
+        nMaterialBuilderUniformParameter(mNativeObject, type.ordinal(), precision.ordinal(), name);
         return this;
     }
 
     @NonNull
     public MaterialBuilder uniformParameterArray(@NonNull UniformType type, int size, String name) {
-        nMaterialBuilderUniformParameterArray(mNativeObject, type.ordinal(), size, name);
+        nMaterialBuilderUniformParameterArray(mNativeObject, type.ordinal(), size,
+                ParameterPrecision.DEFAULT.ordinal(), name);
+        return this;
+    }
+
+    @NonNull
+    public MaterialBuilder uniformParameterArray(@NonNull UniformType type, int size,
+            ParameterPrecision precision, String name) {
+        nMaterialBuilderUniformParameterArray(mNativeObject, type.ordinal(), size,
+                precision.ordinal(), name);
         return this;
     }
 
     @NonNull
     public MaterialBuilder samplerParameter(@NonNull SamplerType type, SamplerFormat format,
-            SamplerPrecision precision, String name) {
+            ParameterPrecision precision, String name) {
         nMaterialBuilderSamplerParameter(
                 mNativeObject, type.ordinal(), format.ordinal(), precision.ordinal(), name);
         return this;
@@ -337,6 +366,12 @@ public class MaterialBuilder {
         return this;
     }
 
+    @NonNull
+    public MaterialBuilder transparentShadow(boolean transparentShadow) {
+        nMaterialBuilderTransparentShadow(mNativeObject, transparentShadow);
+        return this;
+    }
+
     @NonNull
     public MaterialBuilder specularAntiAliasing(boolean specularAntiAliasing) {
         nMaterialBuilderSpecularAntiAliasing(mNativeObject, specularAntiAliasing);
@@ -379,6 +414,12 @@ public class MaterialBuilder {
         return this;
     }
 
+    @NonNull
+    public MaterialBuilder customSurfaceShading(boolean customSurfaceShading) {
+        nMaterialBuilderCustomSurfaceShading(mNativeObject, customSurfaceShading);
+        return this;
+    }
+
     @NonNull
     public MaterialBuilder multiBounceAmbientOcclusion(boolean multiBounceAO) {
         nMaterialBuilderMultiBounceAmbientOcclusion(mNativeObject, multiBounceAO);
@@ -421,9 +462,55 @@ public class MaterialBuilder {
         return this;
     }
 
+    /**
+     * Validates, builds, and returns the compiled material. While this method never
+     * returns null, the returned {@link MaterialPackage} may be invalid. Call
+     * {@link MaterialPackage#isValid()} before using it.
+     *
+     * Calling this method is equivalent to calling {@link #build(Object)} and passing
+     * <code>null</code> as the job system provider.
+     *
+     * @see #build(Object)
+     */
     @NonNull
     public MaterialPackage build() {
-        long nativePackage = nBuilderBuild(mNativeObject);
+        return build(null);
+    }
+
+    /**
+     * Validates, builds, and returns the compiled material. While this method never
+     * returns null, the returned {@link MaterialPackage} may be invalid. Call
+     * {@link MaterialPackage#isValid()} before using it.
+     *
+     * You can pass a job system provider to this method, or null. When passing null
+     * or an invalid job system provider, a temporary job system will be created which
+     * is less efficient than reusing an existing job system.
+     *
+     * Currently the only valid type of job system provider is an <code>Engine</code>
+     * instance from the main Filament library (<code>com.google.android.filament.Engine</code>).
+     *
+     * If you are using Filament and the filamat library together you <em>must</em> pass an
+     * <code>Engine</code> as the job system provider, <em>or</em> invoke
+     * <code>MaterialBuilder</code> from a thread other than the thread used to invoke Filament
+     * APIs.
+     *
+     * @param jobSystemProvider An <code>Engine</code> instance or null
+     */
+    @NonNull
+    public MaterialPackage build(@Nullable Object jobSystemProvider) {
+        long nativeJobSystem = 0;
+        if (jobSystemProvider != null && sEngineClass != null) {
+            if (sEngineClass.isInstance(jobSystemProvider) && sGetNativeJobSystemMethod != null) {
+                try {
+                    //noinspection ConstantConditions
+                    nativeJobSystem = (Long) sGetNativeJobSystemMethod.invoke(jobSystemProvider);
+                } catch (IllegalAccessException | InvocationTargetException e) {
+                    // Ignore
+                }
+            }
+        }
+
+        long nativePackage = nBuilderBuild(mNativeObject, nativeJobSystem);
         byte[] data = nGetPackageBytes(nativePackage);
         MaterialPackage result =
                 new MaterialPackage(ByteBuffer.wrap(data), nGetPackageIsValid(nativePackage));
@@ -455,7 +542,7 @@ public class MaterialBuilder {
     private static native long nCreateMaterialBuilder();
     private static native void nDestroyMaterialBuilder(long nativeBuilder);
 
-    private static native long nBuilderBuild(long nativeBuilder);
+    private static native long nBuilderBuild(long nativeBuilder, long nativeJobSystem);
     private static native byte[] nGetPackageBytes(long nativePackage);
     private static native boolean nGetPackageIsValid(long nativePackage);
     private static native void nDestroyPackage(long nativePackage);
@@ -465,9 +552,9 @@ public class MaterialBuilder {
     private static native void nMaterialBuilderShading(long nativeBuilder, int shading);
     private static native void nMaterialBuilderInterpolation(long nativeBuilder, int interpolation);
     private static native void nMaterialBuilderUniformParameter(long nativeBuilder, int type,
-            String name);
+            int precision, String name);
     private static native void nMaterialBuilderUniformParameterArray(long nativeBuilder, int type,
-            int size, String name);
+            int size, int precision, String name);
     private static native void nMaterialBuilderSamplerParameter(long nativeBuilder, int type,
             int format, int precision, String name);
     private static native void nMaterialBuilderVariable(long nativeBuilder, int variable,
@@ -487,6 +574,8 @@ public class MaterialBuilder {
 
     private static native void nMaterialBuilderShadowMultiplier(long mNativeObject,
             boolean shadowMultiplier);
+    private static native void nMaterialBuilderTransparentShadow(long mNativeObject,
+            boolean transparentShadow);
     private static native void nMaterialBuilderSpecularAntiAliasing(long mNativeObject,
             boolean specularAntiAliasing);
     private static native void nMaterialBuilderSpecularAntiAliasingVariance(long mNativeObject,
@@ -498,6 +587,8 @@ public class MaterialBuilder {
     private static native void nMaterialBuilderClearCoatIorChange(long mNativeObject,
             boolean clearCoatIorChange);
     private static native void nMaterialBuilderFlipUV(long nativeBuilder, boolean flipUV);
+    private static native void nMaterialBuilderCustomSurfaceShading(long nativeBuilder,
+            boolean customSurfaceShading);
     private static native void nMaterialBuilderMultiBounceAmbientOcclusion(long nativeBuilder,
             boolean multiBounceAO);
     private static native void nMaterialBuilderSpecularAmbientOcclusion(long nativeBuilder,

android/filament-android/CMakeLists.txt

@@ -1,7 +1,9 @@
-cmake_minimum_required(VERSION 3.6)
+cmake_minimum_required(VERSION 3.19)
+project(filament-android)
 
 option(FILAMENT_SUPPORTS_VULKAN "Enables Vulkan on Android" OFF)
 option(FILAMENT_ENABLE_MATDBG "Enables Material debugger" OFF)
+option(FILAMENT_DISABLE_MATOPT "Disables material optimizations" OFF)
 
 set(FILAMENT_DIR ${FILAMENT_DIST_DIR})
 
@@ -17,14 +19,18 @@ add_library(utils STATIC IMPORTED)
 set_target_properties(utils PROPERTIES IMPORTED_LOCATION
         ${FILAMENT_DIR}/lib/${ANDROID_ABI}/libutils.a)
 
-add_library(ibl STATIC IMPORTED)
-set_target_properties(ibl PROPERTIES IMPORTED_LOCATION
-        ${FILAMENT_DIR}/lib/${ANDROID_ABI}/libibl.a)
+add_library(ibl-lite STATIC IMPORTED)
+set_target_properties(ibl-lite PROPERTIES IMPORTED_LOCATION
+        ${FILAMENT_DIR}/lib/${ANDROID_ABI}/libibl-lite.a)
 
 add_library(filaflat STATIC IMPORTED)
 set_target_properties(filaflat PROPERTIES IMPORTED_LOCATION
         ${FILAMENT_DIR}/lib/${ANDROID_ABI}/libfilaflat.a)
 
+add_library(filamat STATIC IMPORTED)
+set_target_properties(filamat PROPERTIES IMPORTED_LOCATION
+        ${FILAMENT_DIR}/lib/${ANDROID_ABI}/libfilamat.a)
+
 add_library(geometry STATIC IMPORTED)
 set_target_properties(geometry PROPERTIES IMPORTED_LOCATION
         ${FILAMENT_DIR}/lib/${ANDROID_ABI}/libgeometry.a)
@@ -37,6 +43,10 @@ add_library(bluevk STATIC IMPORTED)
 set_target_properties(bluevk PROPERTIES IMPORTED_LOCATION
         ${FILAMENT_DIR}/lib/${ANDROID_ABI}/libbluevk.a)
 
+add_library(vkshaders STATIC IMPORTED)
+set_target_properties(vkshaders PROPERTIES IMPORTED_LOCATION
+        ${FILAMENT_DIR}/lib/${ANDROID_ABI}/libvkshaders.a)
+
 add_library(smol-v STATIC IMPORTED)
 set_target_properties(smol-v PROPERTIES IMPORTED_LOCATION
         ${FILAMENT_DIR}/lib/${ANDROID_ABI}/libsmol-v.a)
@@ -51,6 +61,7 @@ set(VERSION_SCRIPT "${CMAKE_CURRENT_SOURCE_DIR}/libfilament-jni.map")
 set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} -Wl,--version-script=${VERSION_SCRIPT}")
 
 add_library(filament-jni SHARED
+    src/main/cpp/BufferObject.cpp
     src/main/cpp/Camera.cpp
     src/main/cpp/Colors.cpp
     src/main/cpp/ColorGrading.cpp
@@ -68,10 +79,13 @@ add_library(filament-jni SHARED
     src/main/cpp/RenderTarget.cpp
     src/main/cpp/Scene.cpp
     src/main/cpp/SkyBox.cpp
+    src/main/cpp/SkinningBuffer.cpp
     src/main/cpp/Stream.cpp
     src/main/cpp/SurfaceOrientation.cpp
+    src/main/cpp/SwapChain.cpp
     src/main/cpp/Texture.cpp
     src/main/cpp/TextureSampler.cpp
+    src/main/cpp/ToneMapper.cpp
     src/main/cpp/TransformManager.cpp
     src/main/cpp/VertexBuffer.cpp
     src/main/cpp/View.cpp
@@ -90,22 +104,28 @@ target_link_libraries(filament-jni
     PRIVATE backend
     PRIVATE filaflat
     PRIVATE filabridge
-    PRIVATE geometry
-    PRIVATE ibl
+    PRIVATE ibl-lite
     PRIVATE log
     PRIVATE GLESv3
     PRIVATE EGL
     PRIVATE android
     PRIVATE jnigraphics
     PRIVATE utils
+
+    # libgeometry is PUBLIC because gltfio uses it.
+    PUBLIC geometry
+
     $<$<STREQUAL:${FILAMENT_ENABLE_MATDBG},ON>:matdbg>
+    $<$<STREQUAL:${FILAMENT_ENABLE_MATDBG},ON>:filamat>
     $<$<STREQUAL:${FILAMENT_SUPPORTS_VULKAN},ON>:bluevk>
+    $<$<STREQUAL:${FILAMENT_SUPPORTS_VULKAN},ON>:vkshaders>
     $<$<STREQUAL:${FILAMENT_SUPPORTS_VULKAN},ON>:smol-v>
 )
 
 target_include_directories(filament-jni PRIVATE
         ..
         ${FILAMENT_DIR}/include
+        ../../filament/backend/include
         ../../third_party/robin-map
         ../../libs/utils/include)
 

android/filament-android/libfilament-jni.map

@@ -1,4 +1,28 @@
 LIBFILAMENT {
-  global: *filament*; JNI*;
+  global:
+    Java_com_google_android_filament_*;
+    JNI*;
+    *filament*BufferObject*;
+    *filament*Camera*;
+    *filament*Color*;
+    *filament*Exposure*;
+    *filament*Skybox*;
+    *filament*Engine*;
+    *filament*RenderableManager*;
+    *filament*Aabb*;
+    *filament*IndirectLight*;
+    *filament*LightManager*;
+    *filament*Renderer*;
+    *filament*RenderTarget*;
+    *filament*Scene*;
+    *filament*ToneMapper*;
+    *filament*Transform*;
+    *filament*Material*;
+    *filament*IndexBuffer*;
+    *filament*VertexBuffer*;
+    *filament*View*;
+    *filament*Texture*;
+    *filament*geometry*;
+
   local: *;
 };

android/filament-android/src/main/cpp/BufferObject.cpp

@@ -0,0 +1,100 @@
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <jni.h>
+
+#include <functional>
+#include <stdlib.h>
+#include <string.h>
+
+#include <filament/BufferObject.h>
+
+#include <backend/BufferDescriptor.h>
+
+#include "common/CallbackUtils.h"
+#include "common/NioUtils.h"
+
+using namespace filament;
+using namespace backend;
+
+extern "C" JNIEXPORT jlong JNICALL
+Java_com_google_android_filament_BufferObject_nCreateBuilder(JNIEnv *env, jclass type) {
+    return (jlong) new BufferObject::Builder();
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_BufferObject_nDestroyBuilder(JNIEnv *env, jclass type,
+        jlong nativeBuilder) {
+    BufferObject::Builder* builder = (BufferObject::Builder *) nativeBuilder;
+    delete builder;
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_BufferObject_nBuilderSize(JNIEnv *env, jclass type,
+        jlong nativeBuilder, jint byteCount) {
+    BufferObject::Builder* builder = (BufferObject::Builder *) nativeBuilder;
+    builder->size((uint32_t) byteCount);
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_BufferObject_nBuilderBindingType(JNIEnv *env, jclass type,
+        jlong nativeBuilder, jint bindingType) {
+    using BindingType = BufferObject::BindingType;
+    BufferObject::Builder* builder = (BufferObject::Builder *) nativeBuilder;
+    BindingType types[] = {BindingType::VERTEX};
+    builder->bindingType(types[bindingType]);
+}
+
+extern "C" JNIEXPORT jlong JNICALL
+Java_com_google_android_filament_BufferObject_nBuilderBuild(JNIEnv *env, jclass type,
+        jlong nativeBuilder, jlong nativeEngine) {
+    BufferObject::Builder* builder = (BufferObject::Builder *) nativeBuilder;
+    Engine *engine = (Engine *) nativeEngine;
+    return (jlong) builder->build(*engine);
+}
+
+extern "C" JNIEXPORT jint JNICALL
+Java_com_google_android_filament_BufferObject_nGetByteCount(JNIEnv *env, jclass type,
+        jlong nativeBufferObject) {
+    BufferObject *bufferObject = (BufferObject *) nativeBufferObject;
+    return (jint) bufferObject->getByteCount();
+}
+
+extern "C" JNIEXPORT int JNICALL
+Java_com_google_android_filament_BufferObject_nSetBuffer(JNIEnv *env, jclass type,
+        jlong nativeBufferObject, jlong nativeEngine, jobject buffer, int remaining,
+        jint destOffsetInBytes, jint count,
+        jobject handler, jobject runnable) {
+    BufferObject *bufferObject = (BufferObject *) nativeBufferObject;
+    Engine *engine = (Engine *) nativeEngine;
+
+    AutoBuffer nioBuffer(env, buffer, count);
+    void* data = nioBuffer.getData();
+    size_t sizeInBytes = nioBuffer.getSize();
+    if (sizeInBytes > (remaining << nioBuffer.getShift())) {
+        // BufferOverflowException
+        return -1;
+    }
+
+    auto* callback = JniBufferCallback::make(engine, env, handler, runnable, std::move(nioBuffer));
+
+    BufferDescriptor desc(data, sizeInBytes,
+            callback->getHandler(), &JniBufferCallback::postToJavaAndDestroy, callback);
+
+    bufferObject->setBuffer(*engine, std::move(desc), (uint32_t) destOffsetInBytes);
+
+    return 0;
+}

android/filament-android/src/main/cpp/Camera.cpp

@@ -18,6 +18,8 @@
 
 #include <filament/Camera.h>
 
+#include <utils/Entity.h>
+
 #include <math/mat4.h>
 
 using namespace filament;
@@ -47,20 +49,31 @@ Java_com_google_android_filament_Camera_nSetLensProjection(JNIEnv*, jclass,
 
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_Camera_nSetCustomProjection(JNIEnv *env, jclass,
-        jlong nativeCamera, jdoubleArray inMatrix_, jdouble near, jdouble far) {
+        jlong nativeCamera, jdoubleArray inProjection_, jdoubleArray inProjectionForCulling_,
+        jdouble near, jdouble far) {
     Camera *camera = (Camera *) nativeCamera;
-    jdouble *inMatrix = env->GetDoubleArrayElements(inMatrix_, NULL);
-    camera->setCustomProjection(*reinterpret_cast<const filament::math::mat4 *>(inMatrix), near, far);
-    env->ReleaseDoubleArrayElements(inMatrix_, inMatrix, JNI_ABORT);
+    jdouble *inProjection = env->GetDoubleArrayElements(inProjection_, NULL);
+    jdouble *inProjectionForCulling = env->GetDoubleArrayElements(inProjectionForCulling_, NULL);
+    camera->setCustomProjection(
+            *reinterpret_cast<const filament::math::mat4 *>(inProjection),
+            *reinterpret_cast<const filament::math::mat4 *>(inProjectionForCulling),
+            near, far);
+    env->ReleaseDoubleArrayElements(inProjection_, inProjection, JNI_ABORT);
+    env->ReleaseDoubleArrayElements(inProjectionForCulling_, inProjectionForCulling, JNI_ABORT);
 }
 
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_Camera_nSetScaling(JNIEnv* env, jclass,
-        jlong nativeCamera, jdoubleArray inScaling_) {
+        jlong nativeCamera, jdouble x, jdouble y) {
     Camera *camera = (Camera *) nativeCamera;
-    jdouble *inScaling = env->GetDoubleArrayElements(inScaling_, NULL);
-    camera->setScaling(*reinterpret_cast<const filament::math::double4*>(inScaling));
-    env->ReleaseDoubleArrayElements(inScaling_, inScaling, JNI_ABORT);
+    camera->setScaling({(double)x, (double)y});
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_Camera_nSetShift(JNIEnv* env, jclass,
+        jlong nativeCamera, jdouble x, jdouble y) {
+    Camera *camera = (Camera *) nativeCamera;
+    camera->setShift({(double)x, (double)y});
 }
 
 extern "C" JNIEXPORT void JNICALL
@@ -89,10 +102,19 @@ Java_com_google_android_filament_Camera_nSetModelMatrix(JNIEnv *env, jclass,
         jlong nativeCamera, jfloatArray in_) {
     Camera* camera = (Camera *) nativeCamera;
     jfloat *in = env->GetFloatArrayElements(in_, NULL);
-    camera->setModelMatrix(*reinterpret_cast<const filament::math::mat4f*>(in));
+    camera->setModelMatrix((math::mat4)*reinterpret_cast<const filament::math::mat4f*>(in));
     env->ReleaseFloatArrayElements(in_, in, JNI_ABORT);
 }
 
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_Camera_nSetModelMatrixFp64(JNIEnv *env, jclass,
+        jlong nativeCamera, jdoubleArray in_) {
+    Camera* camera = (Camera *) nativeCamera;
+    jdouble *in = env->GetDoubleArrayElements(in_, NULL);
+    camera->setModelMatrix(*reinterpret_cast<const filament::math::mat4*>(in));
+    env->ReleaseDoubleArrayElements(in_, in, JNI_ABORT);
+}
+
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_Camera_nGetProjectionMatrix(JNIEnv *env, jclass,
         jlong nativeCamera, jdoubleArray out_) {
@@ -128,21 +150,41 @@ Java_com_google_android_filament_Camera_nGetModelMatrix(JNIEnv *env, jclass,
         jlong nativeCamera, jfloatArray out_) {
     Camera *camera = (Camera *) nativeCamera;
     jfloat *out = env->GetFloatArrayElements(out_, NULL);
-    const filament::math::mat4f& m = camera->getModelMatrix();
+    const filament::math::mat4f& m = (math::mat4f)camera->getModelMatrix();
     std::copy_n(&m[0][0], 16, out);
     env->ReleaseFloatArrayElements(out_, out, 0);
 }
 
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_Camera_nGetModelMatrixFp64(JNIEnv *env, jclass,
+        jlong nativeCamera, jdoubleArray out_) {
+    Camera *camera = (Camera *) nativeCamera;
+    jdouble *out = env->GetDoubleArrayElements(out_, NULL);
+    const filament::math::mat4& m = camera->getModelMatrix();
+    std::copy_n(&m[0][0], 16, out);
+    env->ReleaseDoubleArrayElements(out_, out, 0);
+}
+
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_Camera_nGetViewMatrix(JNIEnv *env, jclass, jlong nativeCamera,
         jfloatArray out_) {
     Camera *camera = (Camera *) nativeCamera;
     jfloat *out = env->GetFloatArrayElements(out_, NULL);
-    const filament::math::mat4f& m = camera->getViewMatrix();
+    const filament::math::mat4f& m = (math::mat4f)camera->getViewMatrix();
     std::copy_n(&m[0][0], 16, out);
     env->ReleaseFloatArrayElements(out_, out, 0);
 }
 
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_Camera_nGetViewMatrixFp64(JNIEnv *env, jclass, jlong nativeCamera,
+        jdoubleArray out_) {
+    Camera *camera = (Camera *) nativeCamera;
+    jdouble *out = env->GetDoubleArrayElements(out_, NULL);
+    const filament::math::mat4& m = camera->getViewMatrix();
+    std::copy_n(&m[0][0], 16, out);
+    env->ReleaseDoubleArrayElements(out_, out, 0);
+}
+
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_Camera_nGetPosition(JNIEnv *env, jclass, jlong nativeCamera,
         jfloatArray out_) {
@@ -205,3 +247,36 @@ Java_com_google_android_filament_Camera_nGetSensitivity(JNIEnv*, jclass,
     Camera *camera = (Camera *) nativeCamera;
     return camera->getSensitivity();
 }
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_Camera_nSetFocusDistance(JNIEnv*, jclass,
+        jlong nativeCamera, jfloat focusDistance) {
+    Camera *camera = (Camera *) nativeCamera;
+    camera->setFocusDistance(focusDistance);
+}
+
+extern "C" JNIEXPORT jfloat JNICALL
+Java_com_google_android_filament_Camera_nGetFocusDistance(JNIEnv*, jclass,
+        jlong nativeCamera) {
+    Camera *camera = (Camera *) nativeCamera;
+    return camera->getFocusDistance();
+}
+
+extern "C" JNIEXPORT jdouble JNICALL
+Java_com_google_android_filament_Camera_nGetFocalLength(JNIEnv*, jclass,
+        jlong nativeCamera) {
+    Camera *camera = (Camera *) nativeCamera;
+    return camera->getFocalLength();
+}
+
+extern "C" JNIEXPORT jdouble JNICALL
+Java_com_google_android_filament_Camera_nComputeEffectiveFocalLength(JNIEnv*, jclass,
+        jdouble focalLength, jdouble focusDistance) {
+    return Camera::computeEffectiveFocalLength(focalLength, focusDistance);
+}
+
+extern "C" JNIEXPORT jdouble JNICALL
+Java_com_google_android_filament_Camera_nComputeEffectiveFov(JNIEnv*, jclass,
+        jdouble fovInDegrees, jdouble focusDistance) {
+    return Camera::computeEffectiveFov(fovInDegrees, focusDistance);
+}

android/filament-android/src/main/cpp/ColorGrading.cpp

@@ -17,6 +17,7 @@
 #include <jni.h>
 
 #include <filament/ColorGrading.h>
+#include <filament/ToneMapper.h>
 
 #include <math/vec3.h>
 #include <math/vec4.h>
@@ -30,28 +31,35 @@ Java_com_google_android_filament_ColorGrading_nCreateBuilder(JNIEnv*, jclass) {
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_ColorGrading_nDestroyBuilder(JNIEnv*, jclass,
-        jlong nativeBuilder) {
+Java_com_google_android_filament_ColorGrading_nDestroyBuilder(JNIEnv*, jclass, jlong nativeBuilder) {
     ColorGrading::Builder* builder = (ColorGrading::Builder*) nativeBuilder;
     delete builder;
 }
 
 extern "C" JNIEXPORT jlong JNICALL
-Java_com_google_android_filament_ColorGrading_nBuilderBuild(JNIEnv*, jclass,
-        jlong nativeBuilder, jlong nativeEngine) {
+Java_com_google_android_filament_ColorGrading_nBuilderBuild(JNIEnv*, jclass, jlong nativeBuilder, jlong nativeEngine) {
     ColorGrading::Builder* builder = (ColorGrading::Builder*) nativeBuilder;
     Engine *engine = (Engine *) nativeEngine;
     return (jlong) builder->build(*engine);
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_ColorGrading_nBuilderQuality(JNIEnv*, jclass,
-        jlong nativeBuilder, jint quality_) {
+Java_com_google_android_filament_ColorGrading_nBuilderQuality(JNIEnv*, jclass, jlong nativeBuilder, jint quality_) {
     ColorGrading::Builder* builder = (ColorGrading::Builder*) nativeBuilder;
     ColorGrading::QualityLevel quality = (ColorGrading::QualityLevel) quality_;
     builder->quality(quality);
 }
 
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_ColorGrading_nBuilderToneMapper(JNIEnv*, jclass,
+        jlong nativeBuilder, jlong toneMapper_) {
+    ColorGrading::Builder* builder = (ColorGrading::Builder*) nativeBuilder;
+    const ToneMapper* toneMapper = (const ToneMapper*) toneMapper_;
+    builder->toneMapper(toneMapper);
+}
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_ColorGrading_nBuilderToneMapping(JNIEnv*, jclass,
         jlong nativeBuilder, jint toneMapping_) {
@@ -59,6 +67,35 @@ Java_com_google_android_filament_ColorGrading_nBuilderToneMapping(JNIEnv*, jclas
     ColorGrading::ToneMapping toneMapping = (ColorGrading::ToneMapping) toneMapping_;
     builder->toneMapping(toneMapping);
 }
+#pragma clang diagnostic pop
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_ColorGrading_nBuilderLuminanceScaling(JNIEnv*, jclass,
+        jlong nativeBuilder, jboolean luminanceScaling) {
+    ColorGrading::Builder* builder = (ColorGrading::Builder*) nativeBuilder;
+    builder->luminanceScaling(luminanceScaling);
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_ColorGrading_nBuilderGamutMapping(JNIEnv*, jclass,
+        jlong nativeBuilder, jboolean gamutMapping) {
+    ColorGrading::Builder* builder = (ColorGrading::Builder*) nativeBuilder;
+    builder->gamutMapping(gamutMapping);
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_ColorGrading_nBuilderExposure(JNIEnv*, jclass,
+        jlong nativeBuilder, jfloat exposure) {
+    ColorGrading::Builder* builder = (ColorGrading::Builder*) nativeBuilder;
+    builder->exposure(exposure);
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_ColorGrading_nBuilderNightAdaptation(JNIEnv*, jclass,
+        jlong nativeBuilder, jfloat adaptation) {
+    ColorGrading::Builder* builder = (ColorGrading::Builder*) nativeBuilder;
+    builder->nightAdaptation(adaptation);
+}
 
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_ColorGrading_nBuilderWhiteBalance(JNIEnv*, jclass,

android/filament-android/src/main/cpp/Engine.cpp

@@ -16,6 +16,7 @@
 
 #include <jni.h>
 
+#include <filament/Camera.h>
 #include <filament/Engine.h>
 
 #include <utils/Entity.h>
@@ -44,12 +45,11 @@ extern "C" {
 // handle. Whatever object is returned from this method must match what is in
 // folder filament/src/driver/opengl/Context* in particular pay attention to
 // the object type in makeCurrent method.
-extern void *getNativeWindow(JNIEnv *env, jclass, jobject surface);
+extern void* getNativeWindow(JNIEnv* env, jclass, jobject surface);
 }
 
 extern "C" JNIEXPORT jlong JNICALL
-Java_com_google_android_filament_Engine_nGetBackend(JNIEnv* env,
-        jclass klass, jlong nativeEngine) {
+Java_com_google_android_filament_Engine_nGetBackend(JNIEnv*, jclass, jlong nativeEngine) {
     Engine* engine = (Engine*) nativeEngine;
     return (jlong) engine->getBackend();
 }
@@ -63,8 +63,8 @@ Java_com_google_android_filament_Engine_nCreateSwapChain(JNIEnv* env,
 }
 
 extern "C" JNIEXPORT jlong JNICALL
-Java_com_google_android_filament_Engine_nCreateSwapChainHeadless(JNIEnv* env,
-        jclass klass, jlong nativeEngine, jint width, jint height, jlong flags) {
+Java_com_google_android_filament_Engine_nCreateSwapChainHeadless(JNIEnv*,
+        jclass, jlong nativeEngine, jint width, jint height, jlong flags) {
     Engine* engine = (Engine*) nativeEngine;
     return (jlong) engine->createSwapChain(width, height, (uint64_t) flags);
 }
@@ -80,7 +80,7 @@ extern "C" JNIEXPORT jboolean JNICALL
 Java_com_google_android_filament_Engine_nDestroySwapChain(JNIEnv*, jclass,
         jlong nativeEngine, jlong nativeSwapChain) {
     Engine* engine = (Engine*) nativeEngine;
-    SwapChain *swapChain = (SwapChain *) nativeSwapChain;
+    SwapChain* swapChain = (SwapChain*) nativeSwapChain;
     return engine->destroy(swapChain);
 }
 
@@ -97,7 +97,7 @@ extern "C" JNIEXPORT jboolean JNICALL
 Java_com_google_android_filament_Engine_nDestroyView(JNIEnv*, jclass,
         jlong nativeEngine, jlong nativeView) {
     Engine* engine = (Engine*) nativeEngine;
-    View *view = (View *) nativeView;
+    View* view = (View*) nativeView;
     return engine->destroy(view);
 }
 
@@ -114,21 +114,14 @@ extern "C" JNIEXPORT jboolean JNICALL
 Java_com_google_android_filament_Engine_nDestroyRenderer(JNIEnv*, jclass,
         jlong nativeEngine, jlong nativeRenderer) {
     Engine* engine = (Engine*) nativeEngine;
-    Renderer *renderer = (Renderer *) nativeRenderer;
+    Renderer* renderer = (Renderer*) nativeRenderer;
     return engine->destroy(renderer);
 }
 
 // Camera
 
-extern "C" [[deprecated]] JNIEXPORT jlong JNICALL
-Java_com_google_android_filament_Engine_nCreateCamera(JNIEnv*, jclass,
-        jlong nativeEngine) {
-    Engine* engine = (Engine*) nativeEngine;
-    return (jlong) engine->createCamera();
-}
-
 extern "C" JNIEXPORT jlong JNICALL
-Java_com_google_android_filament_Engine_nCreateCameraWithEntity(JNIEnv*, jclass,
+Java_com_google_android_filament_Engine_nCreateCamera(JNIEnv*, jclass,
         jlong nativeEngine, jint entity_) {
     Engine* engine = (Engine*) nativeEngine;
     Entity& entity = *reinterpret_cast<Entity*>(&entity_);
@@ -143,12 +136,12 @@ Java_com_google_android_filament_Engine_nGetCameraComponent(JNIEnv*, jclass,
     return (jlong) engine->getCameraComponent(entity);
 }
 
-extern "C" [[deprecated]] JNIEXPORT void JNICALL
-Java_com_google_android_filament_Engine_nDestroyCamera(JNIEnv*, jclass,
-        jlong nativeEngine, jlong nativeCamera) {
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_Engine_nDestroyCameraComponent(JNIEnv*, jclass,
+        jlong nativeEngine, jint entity_) {
     Engine* engine = (Engine*) nativeEngine;
-    Camera *camera = (Camera *) nativeCamera;
-    engine->destroy(camera);
+    Entity& entity = *reinterpret_cast<Entity*>(&entity_);
+    engine->destroyCameraComponent(entity);
 }
 
 // Scene
@@ -164,7 +157,7 @@ extern "C" JNIEXPORT jboolean JNICALL
 Java_com_google_android_filament_Engine_nDestroyScene(JNIEnv*, jclass,
         jlong nativeEngine, jlong nativeScene) {
     Engine* engine = (Engine*) nativeEngine;
-    Scene *scene = (Scene *) nativeScene;
+    Scene* scene = (Scene*) nativeScene;
     return engine->destroy(scene);
 }
 
@@ -181,7 +174,7 @@ extern "C" JNIEXPORT jboolean JNICALL
 Java_com_google_android_filament_Engine_nDestroyFence(JNIEnv*, jclass,
         jlong nativeEngine, jlong nativeFence) {
     Engine* engine = (Engine*) nativeEngine;
-    Fence *fence = (Fence *) nativeFence;
+    Fence* fence = (Fence*) nativeFence;
     return engine->destroy(fence);
 }
 
@@ -191,7 +184,7 @@ extern "C" JNIEXPORT jboolean JNICALL
 Java_com_google_android_filament_Engine_nDestroyStream(JNIEnv*, jclass,
         jlong nativeEngine, jlong nativeStream) {
     Engine* engine = (Engine*) nativeEngine;
-    Stream *stream = (Stream *) nativeStream;
+    Stream* stream = (Stream*) nativeStream;
     return engine->destroy(stream);
 }
 
@@ -201,7 +194,7 @@ extern "C" JNIEXPORT jboolean JNICALL
 Java_com_google_android_filament_Engine_nDestroyIndexBuffer(JNIEnv*, jclass,
         jlong nativeEngine, jlong nativeIndexBuffer) {
     Engine* engine = (Engine*) nativeEngine;
-    IndexBuffer *indexBuffer = (IndexBuffer *) nativeIndexBuffer;
+    IndexBuffer* indexBuffer = (IndexBuffer*) nativeIndexBuffer;
     return engine->destroy(indexBuffer);
 }
 
@@ -209,15 +202,23 @@ extern "C" JNIEXPORT jboolean JNICALL
 Java_com_google_android_filament_Engine_nDestroyVertexBuffer(JNIEnv*, jclass,
         jlong nativeEngine, jlong nativeVertexBuffer) {
     Engine* engine = (Engine*) nativeEngine;
-    VertexBuffer *vertexBuffer = (VertexBuffer *) nativeVertexBuffer;
+    VertexBuffer* vertexBuffer = (VertexBuffer*) nativeVertexBuffer;
     return engine->destroy(vertexBuffer);
 }
 
+extern "C" JNIEXPORT jboolean JNICALL
+Java_com_google_android_filament_Engine_nDestroySkinningBuffer(JNIEnv*, jclass,
+        jlong nativeEngine, jlong nativeSkinningBuffer) {
+    Engine* engine = (Engine*) nativeEngine;
+    SkinningBuffer* skinningBuffer = (SkinningBuffer*) nativeSkinningBuffer;
+    return engine->destroy(skinningBuffer);
+}
+
 extern "C" JNIEXPORT jboolean JNICALL
 Java_com_google_android_filament_Engine_nDestroyIndirectLight(JNIEnv*, jclass,
         jlong nativeEngine, jlong nativeIndirectLight) {
     Engine* engine = (Engine*) nativeEngine;
-    IndirectLight *indirectLight = (IndirectLight *) nativeIndirectLight;
+    IndirectLight* indirectLight = (IndirectLight*) nativeIndirectLight;
     return engine->destroy(indirectLight);
 }
 
@@ -225,7 +226,7 @@ extern "C" JNIEXPORT jboolean JNICALL
 Java_com_google_android_filament_Engine_nDestroyMaterial(JNIEnv*, jclass,
         jlong nativeEngine, jlong nativeMaterial) {
     Engine* engine = (Engine*) nativeEngine;
-    Material *material = (Material *) nativeMaterial;
+    Material* material = (Material*) nativeMaterial;
     return engine->destroy(material);
 }
 
@@ -241,7 +242,7 @@ extern "C" JNIEXPORT jboolean JNICALL
 Java_com_google_android_filament_Engine_nDestroySkybox(JNIEnv*, jclass,
         jlong nativeEngine, jlong nativeSkybox) {
     Engine* engine = (Engine*) nativeEngine;
-    Skybox *skybox = (Skybox *) nativeSkybox;
+    Skybox* skybox = (Skybox*) nativeSkybox;
     return engine->destroy(skybox);
 }
 
@@ -257,7 +258,7 @@ extern "C" JNIEXPORT jboolean JNICALL
 Java_com_google_android_filament_Engine_nDestroyTexture(JNIEnv*, jclass,
         jlong nativeEngine, jlong nativeTexture) {
     Engine* engine = (Engine*) nativeEngine;
-    Texture *texture = (Texture *) nativeTexture;
+    Texture* texture = (Texture*) nativeTexture;
     return engine->destroy(texture);
 }
 
@@ -278,7 +279,7 @@ Java_com_google_android_filament_Engine_nDestroyEntity(JNIEnv*, jclass,
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_Engine_nFlushAndWait(JNIEnv *env, jclass clazz,
+Java_com_google_android_filament_Engine_nFlushAndWait(JNIEnv*, jclass,
         jlong nativeEngine) {
     Engine* engine = (Engine*) nativeEngine;
     engine->flushAndWait();
@@ -287,22 +288,31 @@ Java_com_google_android_filament_Engine_nFlushAndWait(JNIEnv *env, jclass clazz,
 // Managers...
 
 extern "C" JNIEXPORT jlong JNICALL
-Java_com_google_android_filament_Engine_nGetTransformManager(JNIEnv*, jclass,
-        jlong nativeEngine) {
+Java_com_google_android_filament_Engine_nGetTransformManager(JNIEnv*, jclass, jlong nativeEngine) {
     Engine* engine = (Engine*) nativeEngine;
     return (jlong) &engine->getTransformManager();
 }
 
 extern "C" JNIEXPORT jlong JNICALL
-Java_com_google_android_filament_Engine_nGetLightManager(JNIEnv*, jclass,
-        jlong nativeEngine) {
+Java_com_google_android_filament_Engine_nGetLightManager(JNIEnv*, jclass, jlong nativeEngine) {
     Engine* engine = (Engine*) nativeEngine;
     return (jlong) &engine->getLightManager();
 }
 
 extern "C" JNIEXPORT jlong JNICALL
-Java_com_google_android_filament_Engine_nGetRenderableManager(JNIEnv*, jclass,
-        jlong nativeEngine) {
+Java_com_google_android_filament_Engine_nGetRenderableManager(JNIEnv*, jclass, jlong nativeEngine) {
     Engine* engine = (Engine*) nativeEngine;
     return (jlong) &engine->getRenderableManager();
 }
+
+extern "C" JNIEXPORT jlong JNICALL
+Java_com_google_android_filament_Engine_nGetJobSystem(JNIEnv*, jclass, jlong nativeEngine) {
+    Engine* engine = (Engine*) nativeEngine;
+    return (jlong) &engine->getJobSystem();
+}
+
+extern "C" JNIEXPORT jlong JNICALL
+Java_com_google_android_filament_Engine_nGetEntityManager(JNIEnv*, jclass, jlong nativeEngine) {
+    Engine* engine = (Engine*) nativeEngine;
+    return (jlong) &engine->getEntityManager();
+}

android/filament-android/src/main/cpp/Filament.cpp

@@ -16,9 +16,7 @@
 
 #include <jni.h>
 
-namespace filament {
-    extern jint JNI_OnLoad(JavaVM* vm, void* reserved);
-};
+#include "private/backend/VirtualMachineEnv.h"
 
 JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
     JNIEnv* env;
@@ -26,9 +24,9 @@ JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
         return -1;
     }
 
-#if ANDROID
-    ::filament::JNI_OnLoad(vm, reserved);
-#endif
+    // This must be called when the library is loaded. We need this to get a reference to the
+    // global VM
+    ::filament::VirtualMachineEnv::JNI_OnLoad(vm);
 
     return JNI_VERSION_1_6;
 }

android/filament-android/src/main/cpp/IndexBuffer.cpp

@@ -91,7 +91,8 @@ Java_com_google_android_filament_IndexBuffer_nSetBuffer(JNIEnv *env, jclass type
 
     auto* callback = JniBufferCallback::make(engine, env, handler, runnable, std::move(nioBuffer));
 
-    BufferDescriptor desc(data, sizeInBytes, &JniBufferCallback::invoke, callback);
+    BufferDescriptor desc(data, sizeInBytes,
+            callback->getHandler(), &JniBufferCallback::postToJavaAndDestroy, callback);
 
     indexBuffer->setBuffer(*engine, std::move(desc), (uint32_t) destOffsetInBytes);
 

android/filament-android/src/main/cpp/LightManager.cpp

@@ -76,8 +76,10 @@ extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_LightManager_nBuilderShadowOptions(JNIEnv* env, jclass,
         jlong nativeBuilder, jint mapSize, jint cascades, jfloatArray splitPositions,
         jfloat constantBias, jfloat normalBias, jfloat shadowFar, jfloat shadowNearHint,
-        jfloat shadowFarHint, jboolean stable, jboolean screenSpaceContactShadows, jint stepCount,
-        jfloat maxShadowDistance) {
+        jfloat shadowFarHint, jboolean stable,
+        jfloat polygonOffsetConstant, jfloat polygonOffsetSlope,
+        jboolean screenSpaceContactShadows, jint stepCount,
+        jfloat maxShadowDistance, jint vsmMsaaSamples, jfloat blurWidth, jfloat shadowBulbRadius) {
     LightManager::Builder *builder = (LightManager::Builder *) nativeBuilder;
     LightManager::ShadowOptions shadowOptions {
             .mapSize = (uint32_t)mapSize,
@@ -88,9 +90,16 @@ Java_com_google_android_filament_LightManager_nBuilderShadowOptions(JNIEnv* env,
             .shadowNearHint = shadowNearHint,
             .shadowFarHint = shadowFarHint,
             .stable = (bool)stable,
+            .polygonOffsetConstant = polygonOffsetConstant,
+            .polygonOffsetSlope = polygonOffsetConstant,
             .screenSpaceContactShadows = (bool)screenSpaceContactShadows,
             .stepCount = uint8_t(stepCount),
-            .maxShadowDistance = maxShadowDistance
+            .maxShadowDistance = maxShadowDistance,
+            .vsm = {
+                    .msaaSamples = (uint8_t) vsmMsaaSamples,
+                    .blurWidth = blurWidth
+            },
+            .shadowBulbRadius = shadowBulbRadius
     };
     jfloat *nativeSplits = env->GetFloatArrayElements(splitPositions, NULL);
     const jsize splitCount = std::min((jsize) 3, env->GetArrayLength(splitPositions));
@@ -185,6 +194,23 @@ Java_com_google_android_filament_LightManager_nBuilderHaloFalloff(JNIEnv*, jclas
     builder->sunHaloFalloff(haloFalloff);
 }
 
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_LightManager_nBuilderLightChannel(JNIEnv*, jclass,
+        jlong nativeBuilder, jint channel, jboolean enable) {
+    LightManager::Builder *builder = (LightManager::Builder *) nativeBuilder;
+    builder->lightChannel(channel, (bool)enable);
+}
+
+extern "C" JNIEXPORT jboolean JNICALL
+Java_com_google_android_filament_LightManager_nBuilderBuild(JNIEnv*, jclass,
+        jlong nativeBuilder, jlong nativeEngine, jint entity) {
+    LightManager::Builder *builder = (LightManager::Builder *) nativeBuilder;
+    Engine *engine = (Engine *) nativeEngine;
+    return jboolean(builder->build(*engine, (Entity &) entity) == LightManager::Builder::Success);
+}
+
+// ------------------------------------------------------------------------------------------------
+
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_LightManager_nComputeUniformSplits(JNIEnv* env, jclass,
         jfloatArray splitPositions, jint cascades) {
@@ -209,13 +235,7 @@ Java_com_google_android_filament_LightManager_nComputePracticalSplits(JNIEnv* en
     env->ReleaseFloatArrayElements(splitPositions, nativeSplits, 0);
 }
 
-extern "C" JNIEXPORT jboolean JNICALL
-Java_com_google_android_filament_LightManager_nBuilderBuild(JNIEnv*, jclass,
-        jlong nativeBuilder, jlong nativeEngine, jint entity) {
-    LightManager::Builder *builder = (LightManager::Builder *) nativeBuilder;
-    Engine *engine = (Engine *) nativeEngine;
-    return jboolean(builder->build(*engine, (Entity &) entity) == LightManager::Builder::Success);
-}
+// ------------------------------------------------------------------------------------------------
 
 extern "C" JNIEXPORT jint JNICALL
 Java_com_google_android_filament_LightManager_nGetType(JNIEnv* env,
@@ -376,3 +396,31 @@ Java_com_google_android_filament_LightManager_nIsShadowCaster(JNIEnv*, jclass,
     LightManager *lm = (LightManager *) nativeLightManager;
     return (jboolean)lm->isShadowCaster((LightManager::Instance) i);
 }
+
+extern "C" JNIEXPORT jfloat JNICALL
+Java_com_google_android_filament_LightManager_nGetOuterConeAngle(JNIEnv*, jclass,
+        jlong nativeLightManager, jint i) {
+    LightManager *lm = (LightManager *) nativeLightManager;
+    return (jfloat)lm->getSpotLightOuterCone((LightManager::Instance) i);
+}
+
+extern "C" JNIEXPORT jfloat JNICALL
+Java_com_google_android_filament_LightManager_nGetInnerConeAngle(JNIEnv*, jclass,
+        jlong nativeLightManager, jint i) {
+    LightManager *lm = (LightManager *) nativeLightManager;
+    return (jfloat)lm->getSpotLightInnerCone((LightManager::Instance) i);
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_LightManager_nSetLightChannel(JNIEnv*, jclass,
+        jlong nativeLightManager, jint i, jint channel, jboolean enable) {
+    LightManager *lm = (LightManager *) nativeLightManager;
+    lm->setLightChannel((LightManager::Instance) i, channel, (bool)enable);
+}
+
+extern "C" JNIEXPORT jboolean JNICALL
+Java_com_google_android_filament_LightManager_nGetLightChannel(JNIEnv*, jclass,
+        jlong nativeLightManager, jint i, jint channel) {
+    LightManager const *lm = (LightManager const *) nativeLightManager;
+    return lm->getLightChannel((LightManager::Instance) i, channel);
+}

android/filament-android/src/main/cpp/Material.cpp

@@ -91,7 +91,7 @@ Java_com_google_android_filament_Material_nGetBlendingMode(JNIEnv*, jclass,
 
 extern "C"
 JNIEXPORT jint JNICALL
-Java_com_google_android_filament_Material_nGetRefraction(JNIEnv*, jclass,
+Java_com_google_android_filament_Material_nGetRefractionMode(JNIEnv*, jclass,
         jlong nativeMaterial) {
     Material* material = (Material*) nativeMaterial;
     return (jint)material->getRefractionMode();
@@ -204,9 +204,20 @@ Java_com_google_android_filament_Material_nGetParameters(JNIEnv* env, jclass,
     jfieldID parameterSamplerOffset = env->GetStaticFieldID(parameterClass,
             "SAMPLER_OFFSET", "I");
 
+    jfieldID parameterSubpassOffset = env->GetStaticFieldID(parameterClass,
+            "SUBPASS_OFFSET", "I");
+
     jint offset = env->GetStaticIntField(parameterClass, parameterSamplerOffset);
+    jint subpassOffset = env->GetStaticIntField(parameterClass, parameterSubpassOffset);
     for (size_t i = 0; i < received; i++) {
-        jint type = info[i].isSampler ? (jint) info[i].samplerType + offset : (jint) info[i].type;
+        jint type;
+        if (info[i].isSampler) {
+            type = (jint) info[i].samplerType + offset;
+        } else if (info[i].isSubpass) {
+            type = subpassOffset;
+        } else {
+            type = (jint) info[i].type;
+        }
 
         env->CallStaticVoidMethod(
                 parameterClass, parameterAdd,

android/filament-android/src/main/cpp/MaterialInstance.cpp

@@ -364,3 +364,19 @@ Java_com_google_android_filament_MaterialInstance_nGetMaterial(JNIEnv* env, jcla
     MaterialInstance* instance = (MaterialInstance*) nativeMaterialInstance;
     return (jlong) instance->getMaterial();
 }
+
+extern "C"
+JNIEXPORT jlong JNICALL
+Java_com_google_android_filament_MaterialInstance_nDuplicate(JNIEnv* env, jclass clazz,
+        jlong otherNativeMaterialInstance, jstring name) {
+    MaterialInstance* other = (MaterialInstance*) otherNativeMaterialInstance;
+    const char *cstr = nullptr;
+    if (name != nullptr) {
+        cstr = env->GetStringUTFChars(name, nullptr);
+    }
+    MaterialInstance* mi = MaterialInstance::duplicate(other, cstr);
+    if (name != nullptr) {
+        env->ReleaseStringUTFChars(name, cstr);
+    }
+    return (jlong)mi;
+}

android/filament-android/src/main/cpp/RenderableManager.cpp

@@ -170,6 +170,14 @@ Java_com_google_android_filament_RenderableManager_nBuilderScreenSpaceContactSha
     builder->screenSpaceContactShadows(enabled);
 }
 
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_RenderableManager_nBuilderSkinningBuffer(JNIEnv*, jclass,
+        jlong nativeBuilder, jlong nativeSkinningBuffer, jint boneCount, jint offset) {
+    RenderableManager::Builder *builder = (RenderableManager::Builder *) nativeBuilder;
+    SkinningBuffer *skinningBuffer = (SkinningBuffer *) nativeSkinningBuffer;
+    builder->skinning(skinningBuffer, boneCount, offset);
+}
+
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_RenderableManager_nBuilderSkinning(JNIEnv*, jclass,
         jlong nativeBuilder, jint boneCount) {
@@ -177,6 +185,13 @@ Java_com_google_android_filament_RenderableManager_nBuilderSkinning(JNIEnv*, jcl
     builder->skinning((size_t)boneCount);
 }
 
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_RenderableManager_nEnableSkinningBuffers(JNIEnv*, jclass,
+        jlong nativeBuilder, jboolean enabled) {
+    RenderableManager::Builder *builder = (RenderableManager::Builder *) nativeBuilder;
+    builder->enableSkinningBuffers(enabled);
+}
+
 extern "C" JNIEXPORT jint JNICALL
 Java_com_google_android_filament_RenderableManager_nBuilderSkinningBones(JNIEnv* env, jclass,
         jlong nativeBuilder, jint boneCount, jobject bones, jint remaining) {
@@ -199,6 +214,22 @@ Java_com_google_android_filament_RenderableManager_nBuilderMorphing(JNIEnv*, jcl
     builder->morphing(enabled);
 }
 
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_RenderableManager_nBuilderLightChannel(JNIEnv*, jclass,
+        jlong nativeBuilder, jint channel, jboolean enable) {
+    RenderableManager::Builder *builder = (RenderableManager::Builder *) nativeBuilder;
+    builder->lightChannel(channel, (bool)enable);
+}
+
+// ------------------------------------------------------------------------------------------------
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_RenderableManager_nSetSkinningBuffer(JNIEnv*, jclass,
+        jlong nativeRenderableManager, jint i, jlong nativeSkinningBuffer, jint count, jint offset) {
+    RenderableManager *rm = (RenderableManager *) nativeRenderableManager;
+    SkinningBuffer *sb = (SkinningBuffer *) nativeSkinningBuffer;
+    rm->setSkinningBuffer(i, sb, count, offset);
+}
 
 extern "C" JNIEXPORT jint JNICALL
 Java_com_google_android_filament_RenderableManager_nSetBonesAsMatrices(JNIEnv* env, jclass,
@@ -239,9 +270,9 @@ Java_com_google_android_filament_RenderableManager_nSetMorphWeights(JNIEnv* env,
         jlong nativeRenderableManager, jint instance, jfloatArray weights) {
     RenderableManager *rm = (RenderableManager *) nativeRenderableManager;
     jfloat* vec = env->GetFloatArrayElements(weights, NULL);
-    math::float4 floatvec(vec[0], vec[1], vec[2], vec[3]);
+    jsize count = env->GetArrayLength(weights);
+    rm->setMorphWeights((RenderableManager::Instance)instance, vec, count);
     env->ReleaseFloatArrayElements(weights, vec, JNI_ABORT);
-    rm->setMorphWeights((RenderableManager::Instance)instance, floatvec);
 }
 
 extern "C" JNIEXPORT void JNICALL
@@ -339,21 +370,13 @@ Java_com_google_android_filament_RenderableManager_nSetMaterialInstanceAt(JNIEnv
             materialInstance);
 }
 
-extern "C" JNIEXPORT long JNICALL
+extern "C" JNIEXPORT jlong JNICALL
 Java_com_google_android_filament_RenderableManager_nGetMaterialInstanceAt(JNIEnv*, jclass,
         jlong nativeRenderableManager, jint i, jint primitiveIndex) {
     RenderableManager *rm = (RenderableManager *) nativeRenderableManager;
     return (long) rm->getMaterialInstanceAt((RenderableManager::Instance) i, (size_t) primitiveIndex);
 }
 
-extern "C" JNIEXPORT long JNICALL
-Java_com_google_android_filament_RenderableManager_nGetMaterialAt(JNIEnv*, jclass,
-        jlong nativeRenderableManager, jint i, jint primitiveIndex) {
-    RenderableManager *rm = (RenderableManager *) nativeRenderableManager;
-    MaterialInstance *mi = rm->getMaterialInstanceAt((RenderableManager::Instance) i, (size_t) primitiveIndex);
-    return (long) mi->getMaterial();
-}
-
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_RenderableManager_nSetGeometryAt__JIIIJJII(JNIEnv*,
         jclass, jlong nativeRenderableManager, jint i, jint primitiveIndex, jint primitiveType,
@@ -390,3 +413,17 @@ Java_com_google_android_filament_RenderableManager_nGetEnabledAttributesAt(JNIEn
     AttributeBitset enabled = rm->getEnabledAttributesAt((RenderableManager::Instance) i, (size_t) primitiveIndex);
     return enabled.getValue();
 }
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_RenderableManager_nSetLightChannel(JNIEnv*, jclass,
+        jlong nativeRenderableManager, jint i, jint channel, jboolean enable) {
+    RenderableManager *rm = (RenderableManager *) nativeRenderableManager;
+    rm->setLightChannel((RenderableManager::Instance) i, channel, (bool)enable);
+}
+
+extern "C" JNIEXPORT jboolean JNICALL
+Java_com_google_android_filament_RenderableManager_nGetLightChannel(JNIEnv*, jclass,
+        jlong nativeRenderableManager, jint i, jint channel) {
+    RenderableManager const *rm = (RenderableManager const *) nativeRenderableManager;
+    return rm->getLightChannel((RenderableManager::Instance) i, channel);
+}

android/filament-android/src/main/cpp/Renderer.cpp

@@ -50,6 +50,14 @@ Java_com_google_android_filament_Renderer_nRender(JNIEnv *, jclass, jlong native
     renderer->render(view);
 }
 
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_Renderer_nRenderStandaloneView(JNIEnv *, jclass, jlong nativeRenderer,
+        jlong nativeView) {
+    Renderer *renderer = (Renderer *) nativeRenderer;
+    View *view = (View *) nativeView;
+    renderer->renderStandaloneView(view);
+}
+
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_Renderer_nCopyFrame(JNIEnv *, jclass, jlong nativeRenderer,
         jlong nativeDstSwapChain,
@@ -89,7 +97,8 @@ Java_com_google_android_filament_Renderer_nReadPixels(JNIEnv *env, jclass,
 
     PixelBufferDescriptor desc(buffer, sizeInBytes, (backend::PixelDataFormat) format,
             (backend::PixelDataType) type, (uint8_t) alignment, (uint32_t) left, (uint32_t) top,
-            (uint32_t) stride, &JniBufferCallback::invoke, callback);
+            (uint32_t) stride,
+            callback->getHandler(), &JniBufferCallback::postToJavaAndDestroy, callback);
 
     renderer->readPixels(uint32_t(xoffset), uint32_t(yoffset), uint32_t(width), uint32_t(height),
             std::move(desc));
@@ -124,7 +133,8 @@ Java_com_google_android_filament_Renderer_nReadPixelsEx(JNIEnv *env, jclass,
 
     PixelBufferDescriptor desc(buffer, sizeInBytes, (backend::PixelDataFormat) format,
             (backend::PixelDataType) type, (uint8_t) alignment, (uint32_t) left, (uint32_t) top,
-            (uint32_t) stride, &JniBufferCallback::invoke, callback);
+            (uint32_t) stride,
+            callback->getHandler(), &JniBufferCallback::postToJavaAndDestroy, callback);
 
     renderer->readPixels(renderTarget,
             uint32_t(xoffset), uint32_t(yoffset), uint32_t(width), uint32_t(height),

android/filament-android/src/main/cpp/SkinningBuffer.cpp

@@ -0,0 +1,116 @@
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <jni.h>
+
+#include <functional>
+#include <stdlib.h>
+#include <string.h>
+
+#include <filament/SkinningBuffer.h>
+
+#include "common/CallbackUtils.h"
+#include "common/NioUtils.h"
+
+using namespace filament;
+using namespace backend;
+
+extern "C"
+JNIEXPORT jlong JNICALL
+Java_com_google_android_filament_SkinningBuffer_nCreateBuilder(JNIEnv*, jclass) {
+    return (jlong) new SkinningBuffer::Builder();
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_google_android_filament_SkinningBuffer_nDestroyBuilder(JNIEnv*, jclass,
+        jlong nativeBuilder) {
+    SkinningBuffer::Builder* builder = (SkinningBuffer::Builder *) nativeBuilder;
+    delete builder;
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_google_android_filament_SkinningBuffer_nBuilderBoneCount(JNIEnv*, jclass,
+        jlong nativeBuilder, jint boneCount) {
+    SkinningBuffer::Builder* builder = (SkinningBuffer::Builder *) nativeBuilder;
+    builder->boneCount((uint32_t)boneCount);
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_google_android_filament_SkinningBuffer_nBuilderInitialize(JNIEnv*, jclass,
+        jlong nativeBuilder, jboolean initialize) {
+    SkinningBuffer::Builder* builder = (SkinningBuffer::Builder *) nativeBuilder;
+    builder->initialize((bool)initialize);
+}
+
+extern "C"
+JNIEXPORT jlong JNICALL
+Java_com_google_android_filament_SkinningBuffer_nBuilderBuild(JNIEnv*, jclass,
+        jlong nativeBuilder, jlong nativeEngine) {
+    SkinningBuffer::Builder* builder = (SkinningBuffer::Builder *) nativeBuilder;
+    Engine *engine = (Engine *) nativeEngine;
+    return (jlong) builder->build(*engine);
+}
+
+// ------------------------------------------------------------------------------------------------
+
+extern "C"
+JNIEXPORT jint JNICALL
+Java_com_google_android_filament_SkinningBuffer_nSetBonesAsMatrices(JNIEnv* env, jclass,
+        jlong nativeSkinningBuffer, jlong nativeEngine, jobject matrices, jint remaining, jint boneCount,
+        jint offset) {
+    SkinningBuffer *skinningBuffer = (SkinningBuffer *) nativeSkinningBuffer;
+    Engine *engine = (Engine *) nativeEngine;
+    AutoBuffer nioBuffer(env, matrices, boneCount * 16);
+    void* data = nioBuffer.getData();
+    size_t sizeInBytes = nioBuffer.getSize();
+    if (sizeInBytes > (remaining << nioBuffer.getShift())) {
+        // BufferOverflowException
+        return -1;
+    }
+    skinningBuffer->setBones(*engine,
+            static_cast<filament::math::mat4f const *>(data), (size_t)boneCount, (size_t)offset);
+    return 0;
+}
+
+extern "C"
+JNIEXPORT jint JNICALL
+Java_com_google_android_filament_SkinningBuffer_nSetBonesAsQuaternions(JNIEnv* env, jclass,
+        jlong nativeSkinningBuffer, jlong nativeEngine, jobject quaternions, jint remaining,
+        jint boneCount, jint offset) {
+    SkinningBuffer *skinningBuffer = (SkinningBuffer *) nativeSkinningBuffer;
+    Engine *engine = (Engine *) nativeEngine;
+    AutoBuffer nioBuffer(env, quaternions, boneCount * 8);
+    void* data = nioBuffer.getData();
+    size_t sizeInBytes = nioBuffer.getSize();
+    if (sizeInBytes > (remaining << nioBuffer.getShift())) {
+        // BufferOverflowException
+        return -1;
+    }
+    skinningBuffer->setBones(*engine,
+            static_cast<RenderableManager::Bone const *>(data), (size_t)boneCount, (size_t)offset);
+    return 0;
+}
+
+extern "C"
+JNIEXPORT jint JNICALL
+Java_com_google_android_filament_SkinningBuffer_nGetBoneCount(JNIEnv*, jclass,
+        jlong nativeSkinningBuffer) {
+    SkinningBuffer *skinningBuffer = (SkinningBuffer *) nativeSkinningBuffer;
+    return (jint)skinningBuffer->getBoneCount();
+}

android/filament-android/src/main/cpp/SkyBox.cpp

@@ -100,7 +100,7 @@ Java_com_google_android_filament_Skybox_nSetColor(JNIEnv *, jclass,
 }
 
 extern "C" JNIEXPORT jlong JNICALL
-Java_com_google_android_filament_Skybix_nGetTexture(JNIEnv* env, jclass,
+Java_com_google_android_filament_Skybox_nGetTexture(JNIEnv* env, jclass,
         jlong nativeSkybox) {
     Skybox *skybox = (Skybox *) nativeSkybox;
     Texture const *tex = skybox->getTexture();

android/filament-android/src/main/cpp/Stream.cpp

@@ -24,7 +24,7 @@
 #include "common/NioUtils.h"
 #include "common/CallbackUtils.h"
 
-#ifdef ANDROID
+#ifdef __ANDROID__
 
 #if __has_include(<android/hardware_buffer_jni.h>)
 #include <android/hardware_buffer_jni.h>
@@ -102,7 +102,10 @@ extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_Stream_nBuilderStream(JNIEnv*, jclass,
         jlong nativeStreamBuilder, jlong externalTextureId) {
     StreamBuilder* builder = (StreamBuilder*) nativeStreamBuilder;
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
     builder->builder()->stream(externalTextureId);
+#pragma clang diagnostic pop
 }
 
 extern "C" JNIEXPORT void JNICALL
@@ -166,7 +169,8 @@ Java_com_google_android_filament_Stream_nReadPixels(JNIEnv *env, jclass,
 
     PixelBufferDescriptor desc(buffer, sizeInBytes, (backend::PixelDataFormat) format,
             (backend::PixelDataType) type, (uint8_t) alignment, (uint32_t) left, (uint32_t) top,
-            (uint32_t) stride, &JniBufferCallback::invoke, callback);
+            (uint32_t) stride,
+            callback->getHandler(), &JniBufferCallback::postToJavaAndDestroy, callback);
 
     stream->readPixels(uint32_t(xoffset), uint32_t(yoffset), uint32_t(width), uint32_t(height),
             std::move(desc));
@@ -186,7 +190,7 @@ Java_com_google_android_filament_Stream_nSetAcquiredImage(JNIEnv* env, jclass, j
     Engine* engine = (Engine*) nativeEngine;
     Stream* stream = (Stream*) nativeStream;
 
-#ifdef ANDROID
+#ifdef __ANDROID__
 
     // This function is not available before NDK 15 or before Android 8.
     if (UTILS_UNLIKELY(!AHardwareBuffer_fromHardwareBuffer_fn)) {
@@ -218,5 +222,6 @@ Java_com_google_android_filament_Stream_nSetAcquiredImage(JNIEnv* env, jclass, j
 
 #endif
 
-    stream->setAcquiredImage((void*) nativeBuffer, &JniImageCallback::invoke, callback);
+    stream->setAcquiredImage((void*) nativeBuffer,
+            callback->getHandler(), &JniImageCallback::postToJavaAndDestroy, callback);
 }

android/filament-android/src/main/cpp/SwapChain.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2019 The Android Open Source Project
+ * Copyright (C) 2020 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.
@@ -16,21 +16,19 @@
 
 #include <jni.h>
 
-#include <gltfio/MaterialProvider.h>
+#include <filament/SwapChain.h>
+
+#include "common/CallbackUtils.h"
 
 using namespace filament;
-using namespace gltfio;
-
-extern "C" JNIEXPORT jlong JNICALL
-Java_com_google_android_filament_gltfio_MaterialProvider_nCreateMaterialProvider(JNIEnv*, jclass,
-        jlong nativeEngine) {
-    Engine* engine = (Engine*) nativeEngine;
-    return (jlong) createUbershaderLoader(engine);
-}
 
 extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_gltfio_MaterialProvider_nDestroyMaterialProvider(JNIEnv*, jclass,
-        jlong nativeProvider) {
-    auto provider = (MaterialProvider*) nativeProvider;
-    delete provider;
+Java_com_google_android_filament_SwapChain_nSetFrameCompletedCallback(JNIEnv* env, jclass,
+        jlong nativeSwapChain, jobject handler, jobject runnable) {
+    SwapChain* swapChain = (SwapChain*) nativeSwapChain;
+    auto *callback = JniCallback::make(env, handler, runnable);
+    swapChain->setFrameCompletedCallback([](void* user) {
+        JniCallback* callback = (JniCallback*)user;
+        JniCallback::postToJavaAndDestroy(callback);
+    }, callback);
 }

android/filament-android/src/main/cpp/Texture.cpp

@@ -19,7 +19,7 @@
 #include <algorithm>
 #include <functional>
 
-#ifdef ANDROID
+#ifdef __ANDROID__
 #include <android/bitmap.h>
 #endif
 
@@ -31,15 +31,18 @@
 #include "common/CallbackUtils.h"
 #include "common/NioUtils.h"
 
+#include "private/backend/VirtualMachineEnv.h"
+
 using namespace filament;
 using namespace backend;
 
-static size_t getTextureDataSize(const Texture *texture, size_t level,
-        Texture::Format format, Texture::Type type, size_t stride, size_t alignment) {
+static size_t getTextureDataSize(const Texture *texture,
+        size_t level, Texture::Format format, Texture::Type type,
+        size_t stride, size_t height, size_t alignment) {
     // Zero stride implies tight row-to-row packing.
-    stride = stride == 0 ? texture->getWidth(level) : std::max(size_t(1), stride >> level);
-    return Texture::computeTextureDataSize(format, type,
-            stride, texture->getHeight(level), alignment);
+    stride = stride == 0 ? texture->getWidth(level)  : std::max(size_t(1), stride >> level);
+    height = height == 0 ? texture->getHeight(level) : std::max(size_t(1), height >> level);
+    return Texture::computeTextureDataSize(format, type, stride, height, alignment);
 }
 
 extern "C" JNIEXPORT jboolean JNICALL
@@ -50,6 +53,13 @@ Java_com_google_android_filament_Texture_nIsTextureFormatSupported(JNIEnv*, jcla
             (Texture::InternalFormat) internalFormat);
 }
 
+extern "C" JNIEXPORT jboolean JNICALL
+Java_com_google_android_filament_Texture_nIsTextureSwizzleSupported(JNIEnv*, jclass,
+        jlong nativeEngine) {
+    Engine *engine = (Engine *) nativeEngine;
+    return (jboolean) Texture::isTextureSwizzleSupported(*engine);
+}
+
 // Texture::Builder...
 
 extern "C" JNIEXPORT jlong JNICALL
@@ -121,6 +131,13 @@ Java_com_google_android_filament_Texture_nBuilderSwizzle(JNIEnv *, jclass ,
             (Texture::Swizzle)r, (Texture::Swizzle)g, (Texture::Swizzle)b, (Texture::Swizzle)a);
 }
 
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_google_android_filament_Texture_nBuilderImportTexture(JNIEnv*, jclass, jlong nativeBuilder, jlong id) {
+    Texture::Builder *builder = (Texture::Builder *) nativeBuilder;
+    builder->import((intptr_t)id);
+}
+
 extern "C" JNIEXPORT jlong JNICALL
 Java_com_google_android_filament_Texture_nBuilderBuild(JNIEnv*, jclass,
         jlong nativeBuilder, jlong nativeEngine) {
@@ -175,14 +192,14 @@ extern "C" JNIEXPORT jint JNICALL
 Java_com_google_android_filament_Texture_nSetImage(JNIEnv* env, jclass, jlong nativeTexture,
         jlong nativeEngine, jint level, jint xoffset, jint yoffset, jint width, jint height,
         jobject storage,  jint remaining,
-        jint left, jint bottom, jint type, jint alignment,
+        jint left, jint top, jint type, jint alignment,
         jint stride, jint format,
         jobject handler, jobject runnable) {
     Texture* texture = (Texture*) nativeTexture;
     Engine* engine = (Engine*) nativeEngine;
 
     size_t sizeInBytes = getTextureDataSize(texture, (size_t) level, (Texture::Format) format,
-            (Texture::Type) type, (size_t) stride, (size_t) alignment);
+            (Texture::Type) type, (size_t) stride, (size_t) height, (size_t) alignment);
 
     AutoBuffer nioBuffer(env, storage, 0);
     if (sizeInBytes > (size_t(remaining) << nioBuffer.getShift())) {
@@ -194,8 +211,9 @@ Java_com_google_android_filament_Texture_nSetImage(JNIEnv* env, jclass, jlong na
     auto *callback = JniBufferCallback::make(engine, env, handler, runnable, std::move(nioBuffer));
 
     Texture::PixelBufferDescriptor desc(buffer, sizeInBytes, (backend::PixelDataFormat) format,
-            (backend::PixelDataType) type, (uint8_t) alignment, (uint32_t) left, (uint32_t) bottom,
-            (uint32_t) stride, &JniBufferCallback::invoke, callback);
+            (backend::PixelDataType) type, (uint8_t) alignment, (uint32_t) left, (uint32_t) top,
+            (uint32_t) stride,
+            callback->getHandler(), &JniBufferCallback::postToJavaAndDestroy, callback);
 
     texture->setImage(*engine, (size_t) level, (uint32_t) xoffset, (uint32_t) yoffset,
             (uint32_t) width, (uint32_t) height, std::move(desc));
@@ -225,7 +243,7 @@ Java_com_google_android_filament_Texture_nSetImageCompressed(JNIEnv *env, jclass
 
     Texture::PixelBufferDescriptor desc(buffer, sizeInBytes,
             (backend::CompressedPixelDataType) compressedFormat, (uint32_t) compressedSizeInBytes,
-            &JniBufferCallback::invoke, callback);
+            callback->getHandler(), &JniBufferCallback::postToJavaAndDestroy, callback);
 
     texture->setImage(*engine, (size_t) level, (uint32_t) xoffset, (uint32_t) yoffset,
             (uint32_t) width, (uint32_t) height, std::move(desc));
@@ -239,14 +257,14 @@ Java_com_google_android_filament_Texture_nSetImage3D(JNIEnv* env, jclass, jlong
         jint xoffset, jint yoffset, jint zoffset,
         jint width, jint height, jint depth,
         jobject storage,  jint remaining,
-        jint left, jint bottom, jint type, jint alignment,
+        jint left, jint top, jint type, jint alignment,
         jint stride, jint format,
         jobject handler, jobject runnable) {
     Texture* texture = (Texture*) nativeTexture;
     Engine* engine = (Engine*) nativeEngine;
 
     size_t sizeInBytes = getTextureDataSize(texture, (size_t) level, (Texture::Format) format,
-            (Texture::Type) type, (size_t) stride, (size_t) alignment);
+            (Texture::Type) type, (size_t) stride, (size_t) height, (size_t) alignment) * depth;
 
     AutoBuffer nioBuffer(env, storage, 0);
     if (sizeInBytes > (size_t(remaining) << nioBuffer.getShift())) {
@@ -258,8 +276,9 @@ Java_com_google_android_filament_Texture_nSetImage3D(JNIEnv* env, jclass, jlong
     auto *callback = JniBufferCallback::make(engine, env, handler, runnable, std::move(nioBuffer));
 
     Texture::PixelBufferDescriptor desc(buffer, sizeInBytes, (backend::PixelDataFormat) format,
-            (backend::PixelDataType) type, (uint8_t) alignment, (uint32_t) left, (uint32_t) bottom,
-            (uint32_t) stride, &JniBufferCallback::invoke, callback);
+            (backend::PixelDataType) type, (uint8_t) alignment, (uint32_t) left, (uint32_t) top,
+            (uint32_t) stride,
+            callback->getHandler(), &JniBufferCallback::postToJavaAndDestroy, callback);
 
     texture->setImage(*engine, (size_t) level,
             (uint32_t) xoffset, (uint32_t) yoffset, (uint32_t) zoffset,
@@ -293,7 +312,7 @@ Java_com_google_android_filament_Texture_nSetImage3DCompressed(JNIEnv *env, jcla
 
     Texture::PixelBufferDescriptor desc(buffer, sizeInBytes,
             (backend::CompressedPixelDataType) compressedFormat, (uint32_t) compressedSizeInBytes,
-            &JniBufferCallback::invoke, callback);
+            callback->getHandler(), &JniBufferCallback::postToJavaAndDestroy, callback);
 
     texture->setImage(*engine, (size_t) level,
             (uint32_t) xoffset, (uint32_t) yoffset, (uint32_t) zoffset,
@@ -306,7 +325,7 @@ Java_com_google_android_filament_Texture_nSetImage3DCompressed(JNIEnv *env, jcla
 extern "C" JNIEXPORT jint JNICALL
 Java_com_google_android_filament_Texture_nSetImageCubemap(JNIEnv *env, jclass,
         jlong nativeTexture, jlong nativeEngine, jint level, jobject storage, jint remaining,
-        jint left, jint bottom, jint type, jint alignment, jint stride, jint format,
+        jint left, jint top, jint type, jint alignment, jint stride, jint format,
         jintArray faceOffsetsInBytes_,
         jobject handler, jobject runnable) {
     Texture *texture = (Texture *) nativeTexture;
@@ -318,7 +337,7 @@ Java_com_google_android_filament_Texture_nSetImageCubemap(JNIEnv *env, jclass,
     env->ReleaseIntArrayElements(faceOffsetsInBytes_, faceOffsetsInBytes, JNI_ABORT);
 
     size_t sizeInBytes = 6 * getTextureDataSize(texture, (size_t) level, (Texture::Format) format,
-            (Texture::Type) type, (size_t) stride, (size_t) alignment);
+            (Texture::Type) type, (size_t) stride, 0, (size_t) alignment);
 
     AutoBuffer nioBuffer(env, storage, 0);
     if (sizeInBytes > (size_t(remaining) << nioBuffer.getShift())) {
@@ -330,8 +349,9 @@ Java_com_google_android_filament_Texture_nSetImageCubemap(JNIEnv *env, jclass,
     auto *callback = JniBufferCallback::make(engine, env, handler, runnable, std::move(nioBuffer));
 
     Texture::PixelBufferDescriptor desc(buffer, sizeInBytes, (backend::PixelDataFormat) format,
-            (backend::PixelDataType) type, (uint8_t) alignment, (uint32_t) left, (uint32_t) bottom,
-            (uint32_t) stride, &JniBufferCallback::invoke, callback);
+            (backend::PixelDataType) type, (uint8_t) alignment, (uint32_t) left, (uint32_t) top,
+            (uint32_t) stride,
+            callback->getHandler(), &JniBufferCallback::postToJavaAndDestroy, callback);
 
     texture->setImage(*engine, (size_t) level, std::move(desc), faceOffsets);
 
@@ -341,7 +361,7 @@ Java_com_google_android_filament_Texture_nSetImageCubemap(JNIEnv *env, jclass,
 extern "C" JNIEXPORT jint JNICALL
 Java_com_google_android_filament_Texture_nSetImageCubemapCompressed(JNIEnv *env, jclass,
         jlong nativeTexture, jlong nativeEngine, jint level, jobject storage, jint remaining,
-        jint left, jint bottom, jint type, jint alignment,
+        jint left, jint top, jint type, jint alignment,
         jint compressedSizeInBytes, jint compressedFormat, jintArray faceOffsetsInBytes_,
         jobject handler, jobject runnable) {
 
@@ -366,7 +386,7 @@ Java_com_google_android_filament_Texture_nSetImageCubemapCompressed(JNIEnv *env,
 
     Texture::PixelBufferDescriptor desc(buffer, sizeInBytes,
             (backend::CompressedPixelDataType) compressedFormat, (uint32_t) compressedSizeInBytes,
-            &JniBufferCallback::invoke, callback);
+            callback->getHandler(), &JniBufferCallback::postToJavaAndDestroy, callback);
 
     texture->setImage(*engine, (size_t) level, std::move(desc), faceOffsets);
 
@@ -439,7 +459,7 @@ Java_com_google_android_filament_Texture_nGeneratePrefilterMipmap(JNIEnv *env, j
     Texture::PixelBufferDescriptor desc(buffer, sizeInBytes, (backend::PixelDataFormat) format,
             (backend::PixelDataType) type, (uint8_t) alignment,
             (uint32_t) left, (uint32_t) top, (uint32_t) stride,
-            &JniBufferCallback::invoke, callback);
+            callback->getHandler(), &JniBufferCallback::postToJavaAndDestroy, callback);
 
     Texture::PrefilterOptions options;
     options.sampleCount = sampleCount;
@@ -453,7 +473,7 @@ Java_com_google_android_filament_Texture_nGeneratePrefilterMipmap(JNIEnv *env, j
 // ANDROID SPECIFIC BITS
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-#ifdef ANDROID
+#ifdef __ANDROID__
 
 #define BITMAP_CONFIG_ALPHA_8   0
 #define BITMAP_CONFIG_RGB_565   1
@@ -462,46 +482,37 @@ Java_com_google_android_filament_Texture_nGeneratePrefilterMipmap(JNIEnv *env, j
 #define BITMAP_CONFIG_RGBA_F16  4
 #define BITMAP_CONFIG_HARDWARE  5
 
-class AutoBitmap {
-public:
+class AutoBitmap : public JniCallback {
+private:
+
     AutoBitmap(JNIEnv* env, jobject bitmap) noexcept
-            : mEnv(env)
-            , mBitmap(env->NewGlobalRef(bitmap))
-    {
+            : JniCallback(),
+              mBitmap(env->NewGlobalRef(bitmap)) {
         if (mBitmap) {
-            AndroidBitmap_getInfo(mEnv, mBitmap, &mInfo);
-            AndroidBitmap_lockPixels(mEnv, mBitmap, &mData);
+            AndroidBitmap_getInfo(env, mBitmap, &mInfo);
+            AndroidBitmap_lockPixels(env, mBitmap, &mData);
         }
     }
 
     AutoBitmap(JNIEnv* env, jobject bitmap, jobject handler, jobject runnable) noexcept
-            : mEnv(env)
-            , mBitmap(env->NewGlobalRef(bitmap))
-            , mHandler(env->NewGlobalRef(handler))
-            , mCallback(env->NewGlobalRef(runnable))
-    {
-        acquireCallbackJni(env, mCallbackUtils);
+            : JniCallback(env, handler, runnable),
+              mBitmap(env->NewGlobalRef(bitmap)) {
         if (mBitmap) {
-            AndroidBitmap_getInfo(mEnv, mBitmap, &mInfo);
-            AndroidBitmap_lockPixels(mEnv, mBitmap, &mData);
+            AndroidBitmap_getInfo(env, mBitmap, &mInfo);
+            AndroidBitmap_lockPixels(env, mBitmap, &mData);
         }
     }
 
-    ~AutoBitmap() noexcept {
-        releaseCallbackJni(mEnv, mCallbackUtils, mHandler, mCallback);
+    void release(JNIEnv* env) {
         if (mBitmap) {
-            AndroidBitmap_unlockPixels(mEnv, mBitmap);
-            mEnv->DeleteGlobalRef(mBitmap);
+            AndroidBitmap_unlockPixels(env, mBitmap);
+            env->DeleteGlobalRef(mBitmap);
         }
     }
 
-    AutoBitmap(AutoBitmap &&rhs) noexcept {
-        mEnv = rhs.mEnv;
-        std::swap(mData, rhs.mData);
-        std::swap(mBitmap, rhs.mBitmap);
-        std::swap(mInfo, rhs.mInfo);
-    }
+    ~AutoBitmap() override = default;
 
+public:
     void* getData() const noexcept {
         return mData;
     }
@@ -528,28 +539,39 @@ public:
         }
     }
 
-    static void invoke(void* buffer, size_t n, void* user) {
-        AutoBitmap* data = reinterpret_cast<AutoBitmap*>(user);
-        delete data;
-    }
-
-    static AutoBitmap* make(Engine* engine, JNIEnv* env, jobject bitmap) {
-        return new AutoBitmap(env, bitmap);
-    }
-
-    static AutoBitmap* make(Engine* engine, JNIEnv* env, jobject bitmap,
-            jobject handler, jobject runnable) {
+    // create a AutoBitmap
+    static AutoBitmap* make(JNIEnv* env, jobject bitmap, jobject handler, jobject runnable) {
         return new AutoBitmap(env, bitmap, handler, runnable);
     }
 
+    // execute the callback on the java thread and destroy ourselves
+    static void invoke(void*, size_t, void* user) {
+        auto* autoBitmap = reinterpret_cast<AutoBitmap*>(user);
+        JNIEnv* env = filament::VirtualMachineEnv::get().getEnvironment();
+        releaseCallbackJni(env, autoBitmap->mCallbackUtils, autoBitmap->mHandler, autoBitmap->mCallback);
+        autoBitmap->release(env);
+        delete autoBitmap;
+    }
+
+    // create a AutoBitmap without a handler
+    static AutoBitmap* make(JNIEnv* env, jobject bitmap) {
+        return new AutoBitmap(env, bitmap);
+    }
+
+    // just destroy ourselves
+    static void invokeNoCallback(void*, size_t, void* user) {
+        auto* autoBitmap = reinterpret_cast<AutoBitmap*>(user);
+        JNIEnv* env = filament::VirtualMachineEnv::get().getEnvironment();
+        autoBitmap->release(env);
+        delete autoBitmap;
+    }
+
 private:
-    JNIEnv* mEnv;
     void* mData = nullptr;
     jobject mBitmap = nullptr;
     jobject mHandler = nullptr;
     jobject mCallback = nullptr;
-    AndroidBitmapInfo mInfo;
-    CallbackJni mCallbackUtils;
+    AndroidBitmapInfo mInfo{};
 };
 
 extern "C"
@@ -560,14 +582,14 @@ Java_com_google_android_filament_android_TextureHelper_nSetBitmap(JNIEnv* env, j
     Texture* texture = (Texture*) nativeTexture;
     Engine *engine = (Engine *) nativeEngine;
 
-    auto* autoBitmap = AutoBitmap::make(engine, env, bitmap);
+    auto* autoBitmap = AutoBitmap::make(env, bitmap);
 
     Texture::PixelBufferDescriptor desc(
             autoBitmap->getData(),
             autoBitmap->getSizeInBytes(),
             autoBitmap->getFormat(format),
             autoBitmap->getType(format),
-            &AutoBitmap::invoke, autoBitmap);
+            &AutoBitmap::invokeNoCallback, autoBitmap);
 
     texture->setImage(*engine, (size_t) level,
             (uint32_t) xoffset, (uint32_t) yoffset,
@@ -583,14 +605,14 @@ Java_com_google_android_filament_android_TextureHelper_nSetBitmapWithCallback(JN
     Texture* texture = (Texture*) nativeTexture;
     Engine *engine = (Engine *) nativeEngine;
 
-    auto* autoBitmap = AutoBitmap::make(engine, env, bitmap, handler, runnable);
+    auto* autoBitmap = AutoBitmap::make(env, bitmap, handler, runnable);
 
     Texture::PixelBufferDescriptor desc(
             autoBitmap->getData(),
             autoBitmap->getSizeInBytes(),
             autoBitmap->getFormat(format),
             autoBitmap->getType(format),
-            &AutoBitmap::invoke, autoBitmap);
+            autoBitmap->getHandler(), &AutoBitmap::invoke, autoBitmap);
 
     texture->setImage(*engine, (size_t) level,
             (uint32_t) xoffset, (uint32_t) yoffset,

android/filament-android/src/main/cpp/ToneMapper.cpp

@@ -0,0 +1,98 @@
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <jni.h>
+
+#include <filament/ToneMapper.h>
+
+using namespace filament;
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_ToneMapper_nDestroyToneMapper(JNIEnv *env, jclass clazz,
+        jlong toneMapper_) {
+    ToneMapper* toneMapper = (ToneMapper*) toneMapper_;
+    delete toneMapper;
+}
+
+extern "C" JNIEXPORT jlong JNICALL
+Java_com_google_android_filament_ToneMapper_nCreateLinearToneMapper(JNIEnv*, jclass) {
+    return (jlong) new LinearToneMapper();
+}
+
+extern "C" JNIEXPORT jlong JNICALL
+Java_com_google_android_filament_ToneMapper_nCreateACESToneMapper(JNIEnv*, jclass) {
+    return (jlong) new ACESToneMapper();
+}
+
+extern "C" JNIEXPORT jlong JNICALL
+Java_com_google_android_filament_ToneMapper_nCreateACESLegacyToneMapper(JNIEnv*, jclass) {
+    return (jlong) new ACESLegacyToneMapper();
+}
+
+extern "C" JNIEXPORT jlong JNICALL
+Java_com_google_android_filament_ToneMapper_nCreateFilmicToneMapper(JNIEnv*, jclass) {
+    return (jlong) new FilmicToneMapper();
+}
+
+extern "C" JNIEXPORT jlong JNICALL
+Java_com_google_android_filament_ToneMapper_nCreateGenericToneMapper(JNIEnv*, jclass,
+        jfloat contrast, jfloat midGrayIn, jfloat midGrayOut, jfloat hdrMax) {
+    return (jlong) new GenericToneMapper(contrast, midGrayIn, midGrayOut, hdrMax);
+}
+
+extern "C" JNIEXPORT jfloat JNICALL
+Java_com_google_android_filament_ToneMapper_nGenericGetContrast(JNIEnv*, jclass, jlong nativeObject) {
+    return ((GenericToneMapper*) nativeObject)->getContrast();
+}
+
+extern "C" JNIEXPORT jfloat JNICALL
+Java_com_google_android_filament_ToneMapper_nGenericGetMidGrayIn(JNIEnv*, jclass, jlong nativeObject) {
+    return ((GenericToneMapper*) nativeObject)->getMidGrayIn();
+}
+
+extern "C" JNIEXPORT jfloat JNICALL
+Java_com_google_android_filament_ToneMapper_nGenericGetMidGrayOut(JNIEnv*, jclass, jlong nativeObject) {
+    return ((GenericToneMapper*) nativeObject)->getMidGrayOut();
+}
+
+extern "C" JNIEXPORT jfloat JNICALL
+Java_com_google_android_filament_ToneMapper_nGenericGetHdrMax(JNIEnv*, jclass, jlong nativeObject) {
+    return ((GenericToneMapper*) nativeObject)->getHdrMax();
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_ToneMapper_nGenericSetContrast(JNIEnv*, jclass,
+        jlong nativeObject, jfloat contrast) {
+    ((GenericToneMapper*) nativeObject)->setContrast(contrast);
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_ToneMapper_nGenericSetMidGrayIn(JNIEnv*, jclass,
+        jlong nativeObject, jfloat midGrayIn) {
+    ((GenericToneMapper*) nativeObject)->setMidGrayIn(midGrayIn);
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_ToneMapper_nGenericSetMidGrayOut(JNIEnv*, jclass,
+        jlong nativeObject, jfloat midGrayOut) {
+    ((GenericToneMapper*) nativeObject)->setMidGrayOut(midGrayOut);
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_ToneMapper_nGenericSetHdrMax(JNIEnv*, jclass,
+        jlong nativeObject, jfloat hdrMax) {
+    ((GenericToneMapper*) nativeObject)->setHdrMax(hdrMax);
+}

android/filament-android/src/main/cpp/TransformManager.cpp

@@ -70,6 +70,23 @@ Java_com_google_android_filament_TransformManager_nCreateArray(JNIEnv* env,
     return tm->getInstance(entity);
 }
 
+extern "C" JNIEXPORT jint JNICALL
+Java_com_google_android_filament_TransformManager_nCreateArrayFp64(JNIEnv* env,
+        jclass, jlong nativeTransformManager, jint entity_, jint parent,
+        jdoubleArray localTransform_) {
+    TransformManager* tm = (TransformManager*) nativeTransformManager;
+    Entity& entity = *reinterpret_cast<Entity*>(&entity_);
+    if (localTransform_) {
+        jdouble *localTransform = env->GetDoubleArrayElements(localTransform_, NULL);
+        tm->create(entity, (TransformManager::Instance) parent,
+                *reinterpret_cast<const filament::math::mat4 *>(localTransform));
+        env->ReleaseDoubleArrayElements(localTransform_, localTransform, JNI_ABORT);
+    } else {
+        tm->create(entity, (TransformManager::Instance) parent);
+    }
+    return tm->getInstance(entity);
+}
+
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_TransformManager_nDestroy(JNIEnv*, jclass,
         jlong nativeTransformManager, jint entity_) {
@@ -86,6 +103,13 @@ Java_com_google_android_filament_TransformManager_nSetParent(JNIEnv*, jclass,
             (TransformManager::Instance) newParent);
 }
 
+extern "C" JNIEXPORT jint JNICALL
+Java_com_google_android_filament_TransformManager_nGetParent(JNIEnv*, jclass,
+        jlong nativeTransformManager, jint i) {
+    TransformManager* tm = (TransformManager*) nativeTransformManager;
+    return tm->getParent((TransformManager::Instance) i).getId();
+}
+
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_TransformManager_nSetTransform(JNIEnv* env,
         jclass, jlong nativeTransformManager, jint i,
@@ -97,6 +121,17 @@ Java_com_google_android_filament_TransformManager_nSetTransform(JNIEnv* env,
     env->ReleaseFloatArrayElements(localTransform_, localTransform, JNI_ABORT);
 }
 
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_TransformManager_nSetTransformFp64(JNIEnv* env,
+        jclass, jlong nativeTransformManager, jint i,
+        jdoubleArray localTransform_) {
+    TransformManager* tm = (TransformManager*) nativeTransformManager;
+    jdouble *localTransform = env->GetDoubleArrayElements(localTransform_, NULL);
+    tm->setTransform((TransformManager::Instance) i,
+            *reinterpret_cast<const filament::math::mat4 *>(localTransform));
+    env->ReleaseDoubleArrayElements(localTransform_, localTransform, JNI_ABORT);
+}
+
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_TransformManager_nGetTransform(JNIEnv* env,
         jclass, jlong nativeTransformManager, jint i,
@@ -108,6 +143,17 @@ Java_com_google_android_filament_TransformManager_nGetTransform(JNIEnv* env,
     env->ReleaseFloatArrayElements(outLocalTransform_, outLocalTransform, 0);
 }
 
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_TransformManager_nGetTransformFp64(JNIEnv* env,
+        jclass, jlong nativeTransformManager, jint i,
+        jdoubleArray outLocalTransform_) {
+    TransformManager* tm = (TransformManager*) nativeTransformManager;
+    jdouble *outLocalTransform = env->GetDoubleArrayElements(outLocalTransform_, NULL);
+    *reinterpret_cast<filament::math::mat4 *>(outLocalTransform) = tm->getTransformAccurate(
+            (TransformManager::Instance) i);
+    env->ReleaseDoubleArrayElements(outLocalTransform_, outLocalTransform, 0);
+}
+
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_TransformManager_nGetWorldTransform(JNIEnv* env,
         jclass, jlong nativeTransformManager, jint i,
@@ -119,6 +165,17 @@ Java_com_google_android_filament_TransformManager_nGetWorldTransform(JNIEnv* env
     env->ReleaseFloatArrayElements(outWorldTransform_, outWorldTransform, 0);
 }
 
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_TransformManager_nGetWorldTransformFp64(JNIEnv* env,
+        jclass, jlong nativeTransformManager, jint i,
+        jdoubleArray outWorldTransform_) {
+    TransformManager* tm = (TransformManager*) nativeTransformManager;
+    jdouble *outWorldTransform = env->GetDoubleArrayElements(outWorldTransform_, NULL);
+    *reinterpret_cast<filament::math::mat4 *>(outWorldTransform) = tm->getWorldTransformAccurate(
+            (TransformManager::Instance) i);
+    env->ReleaseDoubleArrayElements(outWorldTransform_, outWorldTransform, 0);
+}
+
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_TransformManager_nOpenLocalTransformTransaction(
         JNIEnv*, jclass, jlong nativeTransformManager) {
@@ -132,3 +189,19 @@ Java_com_google_android_filament_TransformManager_nCommitLocalTransformTransacti
     TransformManager* tm = (TransformManager*) nativeTransformManager;
     tm->commitLocalTransformTransaction();
 }
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_google_android_filament_TransformManager_nSetAccurateTranslationsEnabled(JNIEnv*,
+        jclass, jlong nativeTransformManager, jboolean enable) {
+    TransformManager* tm = (TransformManager*) nativeTransformManager;
+    tm->setAccurateTranslationsEnabled((bool)enable);
+}
+
+extern "C"
+JNIEXPORT jboolean JNICALL
+Java_com_google_android_filament_TransformManager_nIsAccurateTranslationsEnabled(JNIEnv*,
+        jclass, jlong nativeTransformManager) {
+    TransformManager* tm = (TransformManager*) nativeTransformManager;
+    return (jboolean)tm->isAccurateTranslationsEnabled();
+}

android/filament-android/src/main/cpp/VertexBuffer.cpp

@@ -32,33 +32,40 @@ using namespace filament::math;
 using namespace backend;
 
 extern "C" JNIEXPORT jlong JNICALL
-Java_com_google_android_filament_VertexBuffer_nCreateBuilder(JNIEnv *env, jclass type) {
+Java_com_google_android_filament_VertexBuffer_nCreateBuilder(JNIEnv*, jclass) {
     return (jlong) new VertexBuffer::Builder();
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_VertexBuffer_nDestroyBuilder(JNIEnv *env, jclass type,
+Java_com_google_android_filament_VertexBuffer_nDestroyBuilder(JNIEnv*, jclass,
         jlong nativeBuilder) {
     VertexBuffer::Builder* builder = (VertexBuffer::Builder *) nativeBuilder;
     delete builder;
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_VertexBuffer_nBuilderVertexCount(JNIEnv *env, jclass type,
+Java_com_google_android_filament_VertexBuffer_nBuilderVertexCount(JNIEnv*, jclass,
         jlong nativeBuilder, jint vertexCount) {
     VertexBuffer::Builder* builder = (VertexBuffer::Builder *) nativeBuilder;
     builder->vertexCount((uint32_t) vertexCount);
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_VertexBuffer_nBuilderBufferCount(JNIEnv *env, jclass type,
+Java_com_google_android_filament_VertexBuffer_nBuilderEnableBufferObjects(JNIEnv*, jclass,
+        jlong nativeBuilder, jboolean enabled) {
+    VertexBuffer::Builder* builder = (VertexBuffer::Builder *) nativeBuilder;
+    builder->enableBufferObjects(enabled);
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_VertexBuffer_nBuilderBufferCount(JNIEnv*, jclass,
         jlong nativeBuilder, jint bufferCount) {
     VertexBuffer::Builder* builder = (VertexBuffer::Builder *) nativeBuilder;
     builder->bufferCount((uint8_t) bufferCount);
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_VertexBuffer_nBuilderAttribute(JNIEnv *env, jclass type,
+Java_com_google_android_filament_VertexBuffer_nBuilderAttribute(JNIEnv*, jclass,
         jlong nativeBuilder, jint attribute, jint bufferIndex, jint attributeType, jint byteOffset,
         jint byteStride) {
     VertexBuffer::Builder* builder = (VertexBuffer::Builder *) nativeBuilder;
@@ -68,14 +75,14 @@ Java_com_google_android_filament_VertexBuffer_nBuilderAttribute(JNIEnv *env, jcl
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_VertexBuffer_nBuilderNormalized(JNIEnv *env, jclass type,
+Java_com_google_android_filament_VertexBuffer_nBuilderNormalized(JNIEnv*, jclass,
         jlong nativeBuilder, jint attribute, jboolean normalized) {
     VertexBuffer::Builder* builder = (VertexBuffer::Builder *) nativeBuilder;
     builder->normalized((VertexAttribute) attribute, normalized);
 }
 
 extern "C" JNIEXPORT jlong JNICALL
-Java_com_google_android_filament_VertexBuffer_nBuilderBuild(JNIEnv *env, jclass type,
+Java_com_google_android_filament_VertexBuffer_nBuilderBuild(JNIEnv*, jclass,
         jlong nativeBuilder, jlong nativeEngine) {
     VertexBuffer::Builder* builder = (VertexBuffer::Builder *) nativeBuilder;
     Engine *engine = (Engine *) nativeEngine;
@@ -83,14 +90,14 @@ Java_com_google_android_filament_VertexBuffer_nBuilderBuild(JNIEnv *env, jclass
 }
 
 extern "C" JNIEXPORT jint JNICALL
-Java_com_google_android_filament_VertexBuffer_nGetVertexCount(JNIEnv *env, jclass type,
+Java_com_google_android_filament_VertexBuffer_nGetVertexCount(JNIEnv*, jclass,
         jlong nativeVertexBuffer) {
     VertexBuffer *vertexBuffer = (VertexBuffer *) nativeVertexBuffer;
     return (jint) vertexBuffer->getVertexCount();
 }
 
 extern "C" JNIEXPORT jint JNICALL
-Java_com_google_android_filament_VertexBuffer_nSetBufferAt(JNIEnv *env, jclass type,
+Java_com_google_android_filament_VertexBuffer_nSetBufferAt(JNIEnv *env, jclass,
         jlong nativeVertexBuffer, jlong nativeEngine, jint bufferIndex,
         jobject buffer, jint remaining,
         jint destOffsetInBytes, jint count, jobject handler, jobject runnable) {
@@ -107,7 +114,8 @@ Java_com_google_android_filament_VertexBuffer_nSetBufferAt(JNIEnv *env, jclass t
 
     auto* callback = JniBufferCallback::make(engine, env, handler, runnable, std::move(nioBuffer));
 
-    BufferDescriptor desc(data, sizeInBytes, &JniBufferCallback::invoke, callback);
+    BufferDescriptor desc(data, sizeInBytes,
+            callback->getHandler(), &JniBufferCallback::postToJavaAndDestroy, callback);
 
     vertexBuffer->setBufferAt(*engine, (uint8_t) bufferIndex, std::move(desc),
             (uint32_t) destOffsetInBytes);
@@ -115,42 +123,11 @@ Java_com_google_android_filament_VertexBuffer_nSetBufferAt(JNIEnv *env, jclass t
     return 0;
 }
 
-extern "C" [[deprecated]] JNIEXPORT void JNICALL
-Java_com_google_android_filament_VertexBuffer_nPopulateTangentQuaternions(JNIEnv *env,
-        jclass type, jint quatType, jint quatCount, jobject outBuffer, jint outRemaining,
-        jint outStride, jobject normals, jint normalsRemaining, jint normalsStride,
-        jobject tangents, jint tangentsRemaining, jint tangentsStride) {
-
-    AutoBuffer outNioBuffer(env, outBuffer, outRemaining, true);
-    void* outData = outNioBuffer.getData();
-
-    AutoBuffer normalsNioBuffer(env, normals, normalsRemaining);
-    auto normalsData = (const float3*) normalsNioBuffer.getData();
-
-    if (tangents) {
-        AutoBuffer tangentsNioBuffer(env, tangents, tangentsRemaining);
-        auto tangentsData = (const float4*) tangentsNioBuffer.getData();
-        VertexBuffer::populateTangentQuaternions({
-            .quatType = (VertexBuffer::QuatType) quatType,
-            .quatCount = (size_t) quatCount,
-            .outBuffer = outData,
-            .outStride = (size_t) outStride,
-            .normals = normalsData,
-            .normalsStride = (size_t) normalsStride,
-            .tangents = tangentsData,
-            .tangentsStride = (size_t) tangentsStride
-        });
-        return;
-    }
-
-    VertexBuffer::populateTangentQuaternions({
-        .quatType = (VertexBuffer::QuatType) quatType,
-        .quatCount = (size_t) quatCount,
-        .outBuffer = outData,
-        .outStride = (size_t) outStride,
-        .normals = normalsData,
-        .normalsStride = (size_t) normalsStride,
-        .tangents = nullptr,
-        .tangentsStride = 0
-    });
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_VertexBuffer_nSetBufferObjectAt(JNIEnv*, jclass,
+        jlong nativeVertexBuffer, jlong nativeEngine, jint bufferIndex, jlong nativeBufferObject) {
+    VertexBuffer *vertexBuffer = (VertexBuffer *) nativeVertexBuffer;
+    Engine *engine = (Engine *) nativeEngine;
+    BufferObject *bufferObject = (BufferObject *) nativeBufferObject;
+    vertexBuffer->setBufferObjectAt(*engine, (uint8_t) bufferIndex, bufferObject);
 }

android/filament-android/src/main/cpp/View.cpp

@@ -20,6 +20,10 @@
 #include <filament/View.h>
 #include <filament/Viewport.h>
 
+#include "common/CallbackUtils.h"
+
+#include "private/backend/VirtualMachineEnv.h"
+
 using namespace filament;
 
 extern "C" JNIEXPORT void JNICALL
@@ -67,9 +71,9 @@ Java_com_google_android_filament_View_nSetVisibleLayers(JNIEnv*, jclass, jlong n
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_View_nSetShadowsEnabled(JNIEnv*, jclass, jlong nativeView, jboolean enabled) {
+Java_com_google_android_filament_View_nSetShadowingEnabled(JNIEnv*, jclass, jlong nativeView, jboolean enabled) {
     View* view = (View*) nativeView;
-    view->setShadowsEnabled(enabled);
+    view->setShadowingEnabled(enabled);
 }
 
 extern "C" JNIEXPORT void JNICALL
@@ -82,13 +86,19 @@ Java_com_google_android_filament_View_nSetRenderTarget(JNIEnv*, jclass,
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_View_nSetSampleCount(JNIEnv*, jclass, jlong nativeView, jint count) {
     View* view = (View*) nativeView;
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
     view->setSampleCount((uint8_t) count);
+#pragma clang diagnostic pop
 }
 
 extern "C" JNIEXPORT jint JNICALL
 Java_com_google_android_filament_View_nGetSampleCount(JNIEnv*, jclass, jlong nativeView) {
     View* view = (View*) nativeView;
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
     return view->getSampleCount();
+#pragma clang diagnostic pop
 }
 
 extern "C" JNIEXPORT void JNICALL
@@ -119,17 +129,47 @@ Java_com_google_android_filament_View_nGetDithering(JNIEnv*, jclass,
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_View_nSetDynamicResolutionOptions(JNIEnv*, jclass, jlong nativeView,
         jboolean enabled, jboolean homogeneousScaling,
-        jfloat minScale, jfloat maxScale, jint quality) {
+        jfloat minScale, jfloat maxScale, jfloat sharpness, jint quality) {
     View* view = (View*)nativeView;
     View::DynamicResolutionOptions options;
     options.enabled = enabled;
     options.homogeneousScaling = homogeneousScaling;
     options.minScale = filament::math::float2{ minScale };
     options.maxScale = filament::math::float2{ maxScale };
+    options.sharpness = sharpness;
     options.quality = (View::QualityLevel)quality;
     view->setDynamicResolutionOptions(options);
 }
 
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_View_nSetShadowType(JNIEnv*, jclass, jlong nativeView, jint type) {
+    View* view = (View*) nativeView;
+    view->setShadowType((View::ShadowType) type);
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_View_nSetVsmShadowOptions(JNIEnv*, jclass, jlong nativeView,
+        jint anisotropy, jboolean mipmapping, jfloat minVarianceScale,
+        jfloat lightBleedReduction) {
+    View* view = (View*) nativeView;
+    View::VsmShadowOptions options;
+    options.anisotropy = (uint8_t)anisotropy;
+    options.mipmapping = (bool)mipmapping;
+    options.minVarianceScale = minVarianceScale;
+    options.lightBleedReduction = lightBleedReduction;
+    view->setVsmShadowOptions(options);
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_View_nSetSoftShadowOptions(JNIEnv*, jclass, jlong nativeView,
+        jfloat penumbraScale, jfloat penumbraRatioScale) {
+    View* view = (View*) nativeView;
+    View::SoftShadowOptions options;
+    options.penumbraScale = penumbraScale;
+    options.penumbraRatioScale = penumbraRatioScale;
+    view->setSoftShadowOptions(options);
+}
+
 extern "C"
 JNIEXPORT void JNICALL
 Java_com_google_android_filament_View_nSetRenderQuality(JNIEnv*, jclass,
@@ -196,18 +236,45 @@ Java_com_google_android_filament_View_nGetAmbientOcclusion(JNIEnv*, jclass, jlon
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_View_nSetAmbientOcclusionOptions(JNIEnv*, jclass,
     jlong nativeView, jfloat radius, jfloat bias, jfloat power, jfloat resolution, jfloat intensity,
-    jint quality, jint upsampling, jboolean enabled) {
+    jfloat bilateralThreshold,
+    jint quality, jint lowPassFilter, jint upsampling, jboolean enabled, jboolean bentNormals,
+    jfloat minHorizonAngleRad) {
     View* view = (View*) nativeView;
-    View::AmbientOcclusionOptions options = {
-            .radius = radius,
-            .power = power,
-            .bias = bias,
-            .resolution = resolution,
-            .intensity = intensity,
-            .quality = (View::QualityLevel)quality,
-            .upsampling = (View::QualityLevel)upsampling,
-            .enabled = (bool)enabled
-    };
+    View::AmbientOcclusionOptions options = view->getAmbientOcclusionOptions();
+    options.radius = radius;
+    options.power = power;
+    options.bias = bias;
+    options.resolution = resolution;
+    options.intensity = intensity;
+    options.bilateralThreshold = bilateralThreshold;
+    options.quality = (View::QualityLevel)quality;
+    options.lowPassFilter = (View::QualityLevel)lowPassFilter;
+    options.upsampling = (View::QualityLevel)upsampling;
+    options.enabled = (bool)enabled;
+    options.bentNormals = (bool)bentNormals;
+    options.minHorizonAngleRad = minHorizonAngleRad;
+    view->setAmbientOcclusionOptions(options);
+}
+
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_View_nSetSSCTOptions(JNIEnv *, jclass, jlong nativeView,
+        jfloat ssctLightConeRad, jfloat ssctStartTraceDistance, jfloat ssctContactDistanceMax,
+        jfloat ssctIntensity, jfloat ssctLightDirX, jfloat ssctLightDirY, jfloat ssctLightDirZ,
+        jfloat ssctDepthBias, jfloat ssctDepthSlopeBias, jint ssctSampleCount,
+        jint ssctRayCount, jboolean ssctEnabled) {
+    View* view = (View*) nativeView;
+    View::AmbientOcclusionOptions options = view->getAmbientOcclusionOptions();
+    options.ssct.lightConeRad = ssctLightConeRad;
+    options.ssct.shadowDistance = ssctStartTraceDistance;
+    options.ssct.contactDistanceMax = ssctContactDistanceMax;
+    options.ssct.intensity = ssctIntensity;
+    options.ssct.lightDirection = math::float3{ ssctLightDirX, ssctLightDirY, ssctLightDirZ };
+    options.ssct.depthBias = ssctDepthBias;
+    options.ssct.depthSlopeBias = ssctDepthSlopeBias;
+    options.ssct.sampleCount = (uint8_t)ssctSampleCount;
+    options.ssct.rayCount = (uint8_t)ssctRayCount;
+    options.ssct.enabled = (bool)ssctEnabled;
     view->setAmbientOcclusionOptions(options);
 }
 
@@ -215,7 +282,10 @@ extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_View_nSetBloomOptions(JNIEnv*, jclass,
         jlong nativeView, jlong nativeTexture,
         jfloat dirtStrength, jfloat strength, jint resolution, jfloat anamorphism, jint levels,
-        jint blendMode, jboolean threshold, jboolean enabled, jfloat highlight) {
+        jint blendMode, jboolean threshold, jboolean enabled, jfloat highlight,
+        jboolean lensFlare, jboolean starburst, jfloat chromaticAberration, jint ghostCount,
+        jfloat ghostSpacing, jfloat ghostThreshold, jfloat haloThickness, jfloat haloRadius,
+        jfloat haloThreshold) {
     View* view = (View*) nativeView;
     Texture* dirt = (Texture*) nativeTexture;
     View::BloomOptions options = {
@@ -228,7 +298,16 @@ Java_com_google_android_filament_View_nSetBloomOptions(JNIEnv*, jclass,
             .blendMode = (View::BloomOptions::BlendMode)blendMode,
             .threshold = (bool)threshold,
             .enabled = (bool)enabled,
-            .highlight = highlight
+            .highlight = highlight,
+            .lensFlare = (bool)lensFlare,
+            .starburst = (bool)starburst,
+            .chromaticAberration = chromaticAberration,
+            .ghostCount = (uint8_t)ghostCount,
+            .ghostSpacing = ghostSpacing,
+            .ghostThreshold = ghostThreshold,
+            .haloThickness = haloThickness,
+            .haloRadius = haloRadius,
+            .haloThreshold = haloThreshold
     };
     view->setBloomOptions(options);
 }
@@ -261,11 +340,25 @@ Java_com_google_android_filament_View_nSetBlendMode(JNIEnv *, jclass , jlong nat
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_View_nSetDepthOfFieldOptions(JNIEnv *, jclass ,
-        jlong nativeView, jfloat focusDistance, jfloat blurScale, jfloat maxApertureDiameter, jboolean enabled) {
+Java_com_google_android_filament_View_nSetDepthOfFieldOptions(JNIEnv *, jclass,
+        jlong nativeView, jfloat cocScale, jfloat maxApertureDiameter, jboolean enabled, jint filter,
+        jboolean nativeResolution, jint foregroundRingCount, jint backgroundRingCount, jint fastGatherRingCount,
+        jint maxForegroundCOC, jint maxBackgroundCOC) {
     View* view = (View*) nativeView;
-    view->setDepthOfFieldOptions({.focusDistance = focusDistance, .blurScale = blurScale,
-            .maxApertureDiameter = maxApertureDiameter, .enabled = (bool)enabled});
+    View::DepthOfFieldOptions::Filter eFilter{};
+    if (filter == 1) {
+        // View::DepthOfFieldOptions::Filter::MEDIAN value is actually 2
+        eFilter = View::DepthOfFieldOptions::Filter::MEDIAN;
+    }
+    view->setDepthOfFieldOptions({.cocScale = cocScale,
+            .maxApertureDiameter = maxApertureDiameter, .enabled = (bool)enabled, .filter = eFilter,
+            .nativeResolution = (bool)nativeResolution,
+            .foregroundRingCount = (uint8_t)foregroundRingCount,
+            .backgroundRingCount = (uint8_t)backgroundRingCount,
+            .fastGatherRingCount = (uint8_t)fastGatherRingCount,
+            .maxForegroundCOC = (uint8_t)maxForegroundCOC,
+            .maxBackgroundCOC = (uint8_t)maxBackgroundCOC,
+    });
 }
 
 extern "C"
@@ -277,6 +370,17 @@ Java_com_google_android_filament_View_nSetVignetteOptions(JNIEnv*, jclass, jlong
             .color = LinearColorA{r, g, b, a}, .enabled = (bool)enabled});
 }
 
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_google_android_filament_View_nSetMultiSampleAntiAliasingOptions(JNIEnv* env, jclass clazz,
+        jlong nativeView, jboolean enabled, jint sampleCount, jboolean customResolve) {
+    View* view = (View*) nativeView;
+    view->setMultiSampleAntiAliasingOptions({
+            .enabled = (bool)enabled,
+            .sampleCount = (uint8_t)sampleCount,
+            .customResolve = (bool)customResolve});
+}
+
 extern "C"
 JNIEXPORT void JNICALL
 Java_com_google_android_filament_View_nSetTemporalAntiAliasingOptions(JNIEnv *, jclass,
@@ -285,3 +389,65 @@ Java_com_google_android_filament_View_nSetTemporalAntiAliasingOptions(JNIEnv *,
     view->setTemporalAntiAliasingOptions({
             .filterWidth = filterWidth, .feedback = feedback, .enabled = (bool) enabled});
 }
+
+extern "C"
+JNIEXPORT jboolean JNICALL
+Java_com_google_android_filament_View_nIsShadowingEnabled(JNIEnv *, jclass, jlong nativeView) {
+    View* view = (View*) nativeView;
+    return (jboolean)view->isShadowingEnabled();
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_google_android_filament_View_nSetScreenSpaceRefractionEnabled(JNIEnv *, jclass,
+        jlong nativeView, jboolean enabled) {
+    View* view = (View*) nativeView;
+    view->setScreenSpaceRefractionEnabled((bool)enabled);
+}
+
+extern "C"
+JNIEXPORT jboolean JNICALL
+Java_com_google_android_filament_View_nIsScreenSpaceRefractionEnabled(JNIEnv *, jclass,
+        jlong nativeView) {
+    View* view = (View*) nativeView;
+    return (jboolean)view->isScreenSpaceRefractionEnabled();
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_google_android_filament_View_nPick(JNIEnv* env, jclass,
+        jlong nativeView,
+        jint x, jint y, jobject handler, jobject internalCallback) {
+
+    // jniState will be initialized the first time this method is called
+    static const struct JniState {
+        jclass internalOnPickCallbackClass;
+        jfieldID renderableFieldId;
+        jfieldID depthFieldId;
+        jfieldID fragCoordXFieldId;
+        jfieldID fragCoordYFieldId;
+        jfieldID fragCoordZFieldId;
+        explicit JniState(JNIEnv* env) noexcept {
+            internalOnPickCallbackClass = env->FindClass("com/google/android/filament/View$InternalOnPickCallback");
+            renderableFieldId = env->GetFieldID(internalOnPickCallbackClass, "mRenderable", "I");
+            depthFieldId = env->GetFieldID(internalOnPickCallbackClass, "mDepth", "F");
+            fragCoordXFieldId = env->GetFieldID(internalOnPickCallbackClass, "mFragCoordsX", "F");
+            fragCoordYFieldId = env->GetFieldID(internalOnPickCallbackClass, "mFragCoordsY", "F");
+            fragCoordZFieldId = env->GetFieldID(internalOnPickCallbackClass, "mFragCoordsZ", "F");
+        }
+    } jniState(env);
+
+    View* view = (View*) nativeView;
+    JniCallback *callback = JniCallback::make(env, handler, internalCallback);
+    view->pick(x, y, [callback](View::PickingQueryResult const& result) {
+        // this is executed on the backend/service thread
+        jobject obj = callback->getCallbackObject();
+        JNIEnv* env = filament::VirtualMachineEnv::get().getEnvironment();
+        env->SetIntField(obj, jniState.renderableFieldId, (jint)result.renderable.getId());
+        env->SetFloatField(obj, jniState.depthFieldId, result.depth);
+        env->SetFloatField(obj, jniState.fragCoordXFieldId, result.fragCoords.x);
+        env->SetFloatField(obj, jniState.fragCoordYFieldId, result.fragCoords.y);
+        env->SetFloatField(obj, jniState.fragCoordZFieldId, result.fragCoords.z);
+        JniCallback::postToJavaAndDestroy(callback);
+    }, callback->getHandler());
+}

android/filament-android/src/main/cpp/nativewindow/Darwin.mm

@@ -1,71 +0,0 @@
-/*
- * Copyright (C) 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <stdio.h>
-
-#include <jawt.h>
-
-#if defined(__has_include)
-#if __has_include(<darwin/jawt_md.h>)
-#include <darwin/jawt_md.h>
-#else
-#include <jawt_md.h>
-#endif
-#else
-#include <darwin/jawt_md.h>
-#endif
-
-#include <filament/Engine.h>
-#include "JAWTUtils.h"
-
-#import <Cocoa/Cocoa.h>
-
-#pragma clang diagnostic push
-#pragma ide diagnostic ignored "NotReleasedValue"
-extern "C" {
-void *getNativeWindow(JNIEnv *env, jclass klass, jobject surface) {
-    void *win = nullptr;
-    JAWT_DrawingSurface *ds = nullptr;
-    JAWT_DrawingSurfaceInfo *dsi = nullptr;
-
-    if (!acquireDrawingSurface(env, surface, &ds, &dsi)) {
-        return win;
-    }
-    NSObject<JAWT_SurfaceLayers>* jawldsip = (NSObject<JAWT_SurfaceLayers>*)dsi->platformInfo;
-    // Use jawt_DrawingSurfaceInfo.bounds for frame dimension.
-    NSView *view = [[NSView alloc] initWithFrame:
-            NSMakeRect(dsi->bounds.x, dsi->bounds.y, dsi->bounds.width, dsi->bounds.height)];
-    view.wantsLayer = true;
-    [jawldsip setLayer:view.layer];
-
-    win = (void*) view;
-    releaseDrawingSurface(ds, dsi);
-    return win;
-}
-
-jlong createNativeSurface(jint width, jint height) {
-    NSView *view = [[NSView alloc] initWithFrame:NSMakeRect(0, 0, width, height)];
-    view.wantsLayer = true;
-    return (jlong) view;
-}
-
-void destroyNativeSurface(jlong surface) {
-    NSView *view = reinterpret_cast<NSView*>(surface);
-    [view release];
-}
-
-}
-#pragma clang diagnostic pop

android/filament-android/src/main/cpp/nativewindow/JAWTUtils.cpp

@@ -1,109 +0,0 @@
-/*
- * Copyright (C) 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "JAWTUtils.h"
-
-#include <vector>
-
-static std::vector<int> jawtVersions = {
-        0x00010003,
-        0x00010004,
-        0x00010007,
-        0x00010009,
-};
-
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wuninitialized"
-bool acquireDrawingSurface(JNIEnv* env, jobject surface,
-        JAWT_DrawingSurface** ods, JAWT_DrawingSurfaceInfo** odsi) {
-
-    JAWT awt;
-    JAWT_DrawingSurface* ds = nullptr;
-    JAWT_DrawingSurfaceInfo* dsi = nullptr;
-
-    // Search for a valid AWT
-    jboolean foundJawt = JNI_FALSE;
-    for (int jawtVersion : jawtVersions) {
-        awt.version = jawtVersion;
-        foundJawt = JAWT_GetAWT(env, &awt);
-        if (foundJawt == JNI_TRUE) {
-#ifndef NDEBUG
-            printf("Found valid AWT v%08x.\n", jawtVersion);
-#endif
-            break;
-        } else {
-#ifndef NDEBUG
-            printf("AWT v%08x not present.\n", jawtVersion);
-#endif
-        }
-    }
-#ifndef NDEBUG
-    fflush(stdout);
-#endif
-
-    if (foundJawt == JNI_FALSE) {
-        printf("AWT Not found\n");
-        fflush(stdout);
-        return false;
-    }
-
-    // Get the drawing surface
-    ds = awt.GetDrawingSurface(env, surface);
-    if (ds == nullptr) {
-#ifndef NDEBUG
-        printf("NULL drawing surface\n");
-        fflush(stdout);
-#endif
-        return false;
-    }
-
-    // Lock the drawing
-    jint lock = ds->Lock(ds);
-    if ((lock & JAWT_LOCK_ERROR) != 0) {
-#ifndef NDEBUG
-        printf("Error locking surface\n");
-        fflush(stdout);
-#endif
-        awt.FreeDrawingSurface(ds);
-        return false;
-    }
-
-    // Get the drawing surface info
-    dsi = ds->GetDrawingSurfaceInfo(ds);
-    if (dsi == nullptr) {
-#ifndef NDEBUG
-        printf("Error getting surface info\n");
-        fflush(stdout);
-#endif
-
-        ds->Unlock(ds);
-        awt.FreeDrawingSurface(ds);
-        return false;
-    }
-
-    *odsi = dsi;
-    *ods = ds;
-
-    return true;
-}
-#pragma clang diagnostic pop
-
-void releaseDrawingSurface(JAWT_DrawingSurface* ds, JAWT_DrawingSurfaceInfo* dsi) {
-    // Free the drawing surface info
-    ds->FreeDrawingSurfaceInfo(dsi);
-    // Unlock the drawing surface
-    ds->Unlock(ds);
-}

android/filament-android/src/main/cpp/nativewindow/Linux.cpp

@@ -1,90 +0,0 @@
-/*
- * Copyright (C) 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <stdio.h>
-
-#include <jawt.h>
-#include <linux/jawt_md.h>
-
-#include "JAWTUtils.h"
-#include<GL/glx.h>
-
-extern "C" {
-void *getNativeWindow(JNIEnv* env, jclass, jobject surface) {
-    void* win = nullptr;
-    JAWT_DrawingSurface* ds = nullptr;
-    JAWT_DrawingSurfaceInfo* dsi = nullptr;
-
-    if (!acquireDrawingSurface(env, surface, &ds, &dsi)) {
-        return win;
-    }
-    JAWT_X11DrawingSurfaceInfo* dsi_x11 = (JAWT_X11DrawingSurfaceInfo*) dsi->platformInfo;
-
-    win = (void*) dsi_x11->drawable;
-    releaseDrawingSurface(ds, dsi);
-    return win;
-}
-
-jlong createNativeSurface(jint width, jint height) {
-    Display* display = XOpenDisplay(nullptr);
-    int screen = DefaultScreen(display);
-    Window window = 0;
-
-    #ifndef NDEBUG
-        int major, minor;
-        glXQueryVersion(display, &major, &minor);
-        printf("Using GLX v%d.%d\n", major, minor); fflush(stdout);
-    #endif
-
-    static int visualAttributess[] = {
-        GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
-        GLX_RENDER_TYPE,   GLX_RGBA_BIT,
-        GLX_DOUBLEBUFFER,  True,
-        GLX_RED_SIZE,      8,
-        GLX_GREEN_SIZE,    8,
-        GLX_BLUE_SIZE,     8,
-        GLX_DEPTH_SIZE,   24,
-        None
-    };
-    int numConfigs = 0;
-    GLXFBConfig* configs = glXChooseFBConfig( display, screen, visualAttributess, &numConfigs);
-    if (numConfigs == 0) {
-        printf("Unable to find a suitable Framebuffer Configuration.\n"); fflush(stdout);
-        return 0;
-    }
-
-    int pbufferAttributes[] = {
-        GLX_PBUFFER_WIDTH, width,
-        GLX_PBUFFER_HEIGHT, height,
-        None
-    };
-    window = glXCreatePbuffer( display, configs[0], pbufferAttributes );
-    XFree(configs);
-    // Make sure pbuffer creation has not been buffered in the event queue (we need it NOW).
-    XFlush(display);
-
-    // Camouflage the pbuffer as a window which are both XID anyway.
-    return (jlong) window;
-}
-
-void destroyNativeSurface(jlong surface) {
-    const char* displayName = nullptr;
-    Display* display = XOpenDisplay(displayName);
-    GLXPbuffer pBuffer = (GLXPbuffer)surface;
-    glXDestroyPbuffer(display, pBuffer);
-}
-
-}

android/filament-android/src/main/cpp/nativewindow/Win32.cpp

@@ -1,67 +0,0 @@
-/*
- * Copyright (C) 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <stdio.h>
-
-#include <jawt.h>
-#include <win32/jawt_md.h>
-#include <windows.h>
-
-#include <utils/unwindows.h>
-
-#include "JAWTUtils.h"
-#include <filament/Engine.h>
-
-extern "C" {
-
-void* getNativeWindow(JNIEnv* env, jclass, jobject surface) {
-    JAWT_DrawingSurface* ds = nullptr;
-    JAWT_DrawingSurfaceInfo* dsi = nullptr;
-
-    if (!acquireDrawingSurface(env, surface, &ds, &dsi)) {
-        return nullptr;
-    }
-
-    JAWT_Win32DrawingSurfaceInfo* dsi_win32 = (JAWT_Win32DrawingSurfaceInfo*) dsi->platformInfo;
-    HWND hWnd = dsi_win32->hwnd;
-
-    releaseDrawingSurface(ds, dsi);
-
-    return (void*) hWnd;
-}
-
-
-jlong createNativeSurface(jint width, jint height) {
-    // We need to adjust the window size so the "client area" matches width and height requested.
-    // Otherwise, the window itself will be of dimension width-height but the "client area" and the
-    // resulting surface will be smaller than requested.
-    RECT dimension = {0, 0, width, height};
-    AdjustWindowRect(&dimension, WS_OVERLAPPEDWINDOW, FALSE);
-    width = dimension.right - dimension.left;
-    height = dimension.bottom - dimension.top;
-
-    HWND window = CreateWindowA("STATIC", "dummy", 0, 0, 0, width, height, NULL, NULL, NULL, NULL);
-    SetWindowLong(window, GWL_STYLE, 0); //remove all window styles
-
-    return (jlong) window;
-}
-
-void destroyNativeSurface(jlong surface) {
-    HWND window = (HWND) surface;
-    DestroyWindow(window);
-}
-
-}

android/filament-android/src/main/java/com/google/android/filament/Asserts.java

@@ -63,12 +63,27 @@ final class Asserts {
         return out;
     }
 
+    @NonNull @Size(min = 16)
+    static double[] assertMat4(@Nullable double[] out) {
+        if (out == null) out = new double[16];
+        else if (out.length < 16) {
+            throw new ArrayIndexOutOfBoundsException("Array length must be at least 16");
+        }
+        return out;
+    }
+
     static void assertMat4fIn(@NonNull @Size(min = 16) float[] in) {
         if (in.length < 16) {
             throw new ArrayIndexOutOfBoundsException("Array length must be at least 16");
         }
     }
 
+    static void assertMat4In(@NonNull @Size(min = 16) double[] in) {
+        if (in.length < 16) {
+            throw new ArrayIndexOutOfBoundsException("Array length must be at least 16");
+        }
+    }
+
     @NonNull @Size(min = 3)
     static float[] assertFloat3(@Nullable float[] out) {
         if (out == null) out = new float[3];

android/filament-android/src/main/java/com/google/android/filament/BufferObject.java

@@ -0,0 +1,210 @@
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.android.filament;
+
+import androidx.annotation.IntRange;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import java.nio.Buffer;
+import java.nio.BufferOverflowException;
+
+/**
+ * A generic GPU buffer containing data.
+ *
+ * Usage of this BufferObject is optional. For simple use cases it is not necessary. It is useful
+ * only when you need to share data between multiple VertexBuffer instances. It also allows you to
+ * efficiently swap-out the buffers in VertexBuffer.
+ *
+ * NOTE: For now this is only used for vertex data, but in the future we may use it for other things
+ * (e.g. compute).
+ *
+ * @see VertexBuffer
+ */
+public class BufferObject {
+    private long mNativeObject;
+
+    private BufferObject(long nativeBufferObject) {
+        mNativeObject = nativeBufferObject;
+    }
+
+    public static class Builder {
+        @SuppressWarnings({"FieldCanBeLocal", "UnusedDeclaration"})
+        // Keep to finalize native resources
+        private final BuilderFinalizer mFinalizer;
+        private final long mNativeBuilder;
+
+        public enum BindingType {
+            VERTEX,
+        }
+
+        public Builder() {
+            mNativeBuilder = nCreateBuilder();
+            mFinalizer = new BuilderFinalizer(mNativeBuilder);
+        }
+
+        /**
+         * Size of the buffer in bytes.
+         *
+         * @param byteCount Maximum number of bytes the BufferObject can hold.
+         * @return A reference to this Builder for chaining calls.
+         */
+        @NonNull
+        public Builder size(@IntRange(from = 1) int byteCount) {
+            nBuilderSize(mNativeBuilder, byteCount);
+            return this;
+        }
+
+        /**
+         * The binding type for this buffer object. (defaults to VERTEX)
+         *
+         * @param bindingType Distinguishes between SSBO, VBO, etc. For now this must be VERTEX.
+         * @return A reference to this Builder for chaining calls.
+         */
+        @NonNull
+        public Builder bindingType(@NonNull BindingType bindingType) {
+            nBuilderBindingType(mNativeBuilder, bindingType.ordinal());
+            return this;
+        }
+
+        /**
+         * Creates and returns the <code>BufferObject</code> object. After creation, the buffer
+         * is uninitialized. Use {@link #setBuffer} to initialize the <code>BufferObject</code>.
+         *
+         * @param engine reference to the {@link Engine} to associate this <code>BufferObject</code>
+         *               with
+         *
+         * @return the newly created <code>BufferObject</code> object
+         *
+         * @exception IllegalStateException if the BufferObject could not be created
+         *
+         * @see #setBuffer
+         */
+        @NonNull
+        public BufferObject build(@NonNull Engine engine) {
+            long nativeBufferObject = nBuilderBuild(mNativeBuilder, engine.getNativeObject());
+            if (nativeBufferObject == 0)
+                throw new IllegalStateException("Couldn't create BufferObject");
+            return new BufferObject(nativeBufferObject);
+        }
+
+        private static class BuilderFinalizer {
+            private final long mNativeObject;
+
+            BuilderFinalizer(long nativeObject) {
+                mNativeObject = nativeObject;
+            }
+
+            @Override
+            public void finalize() {
+                try {
+                    super.finalize();
+                } catch (Throwable t) { // Ignore
+                } finally {
+                    nDestroyBuilder(mNativeObject);
+                }
+            }
+        }
+    }
+
+    /**
+     * Returns the size of this <code>BufferObject</code> in elements.
+     *
+     * @return the number of bytes the <code>BufferObject</code> holds
+     */
+    @IntRange(from = 0)
+    public int getByteCount() {
+        return nGetByteCount(getNativeObject());
+    }
+
+    /**
+     * Asynchronously copy-initializes this <code>BufferObject</code> from the data provided.
+     *
+     * @param engine            reference to the {@link Engine} to associate this
+     *                          <code>BufferObject</code> with
+     * @param buffer            a CPU-side {@link Buffer} with the data used to initialize the
+     *                          <code>BufferObject</code>.
+     */
+    public void setBuffer(@NonNull Engine engine, @NonNull Buffer buffer) {
+        setBuffer(engine, buffer, 0, 0, null, null);
+    }
+
+    /**
+     * Asynchronously copy-initializes a region of this <code>BufferObject</code> from the data
+     * provided.
+     *
+     * @param engine            reference to the {@link Engine} to associate this
+     *                          <code>BufferObject</code> with
+     * @param buffer            a CPU-side {@link Buffer} with the data used to initialize the
+     *                          <code>BufferObject</code>.
+     * @param destOffsetInBytes offset in <i>bytes</i> into the <code>BufferObject</code>
+     * @param count             number of bytes to consume, defaults to
+     *                          <code>buffer.remaining()</code>
+     */
+    public void setBuffer(@NonNull Engine engine, @NonNull Buffer buffer,
+            @IntRange(from = 0) int destOffsetInBytes, @IntRange(from = 0) int count) {
+        setBuffer(engine, buffer, destOffsetInBytes, count, null, null);
+    }
+
+    /**
+     * Asynchronously copy-initializes a region of this <code>BufferObject</code> from the data
+     * provided.
+     *
+     * @param engine            reference to the {@link Engine} to associate this
+     *                          <code>BufferObject</code> with
+     * @param buffer            a CPU-side {@link Buffer} with the data used to initialize the
+     *                          <code>BufferObject</code>.
+     * @param destOffsetInBytes offset in <i>bytes</i> into the <code>BufferObject</code>
+     * @param count             number of bytes to consume, defaults to
+     *                          <code>buffer.remaining()</code>
+     * @param handler           an {@link java.util.concurrent.Executor Executor}. On Android this
+     *                          can also be a {@link android.os.Handler Handler}.
+     * @param callback          a callback executed by <code>handler</code> when <code>buffer</code>
+     *                          is no longer needed.
+     */
+    public void setBuffer(@NonNull Engine engine, @NonNull Buffer buffer,
+            @IntRange(from = 0) int destOffsetInBytes, @IntRange(from = 0) int count,
+            @Nullable Object handler, @Nullable Runnable callback) {
+        int result = nSetBuffer(getNativeObject(), engine.getNativeObject(), buffer, buffer.remaining(),
+                destOffsetInBytes, count == 0 ? buffer.remaining() : count, handler, callback);
+        if (result < 0) {
+            throw new BufferOverflowException();
+        }
+    }
+
+    public long getNativeObject() {
+        if (mNativeObject == 0) {
+            throw new IllegalStateException("Calling method on destroyed BufferObject");
+        }
+        return mNativeObject;
+    }
+
+    void clearNativeObject() {
+        mNativeObject = 0;
+    }
+
+    private static native long nCreateBuilder();
+    private static native void nDestroyBuilder(long nativeBuilder);
+    private static native void nBuilderSize(long nativeBuilder, int byteCount);
+    private static native void nBuilderBindingType(long nativeBuilder, int bindingType);
+    private static native long nBuilderBuild(long nativeBuilder, long nativeEngine);
+
+    private static native int nGetByteCount(long nativeBufferObject);
+    private static native int nSetBuffer(long nativeBufferObject, long nativeEngine,
+            Buffer buffer, int remaining,
+            int destOffsetInBytes, int count, Object handler, Runnable callback);
+}

android/filament-android/src/main/java/com/google/android/filament/Camera.java

@@ -27,21 +27,17 @@ import androidx.annotation.Size;
  *
  * <h1><u>Creation and destruction</u></h1>
  *
- * Unlike most Filament objects, Camera doesn't require a builder and can be constructed directly
- * using {@link Engine#createCamera}. At the very least, a projection must be defined
- * using {@link #setProjection}. In most case, the camera position also needs to be set.
- * <p>
- * A Camera object is destroyed using {@link Engine#destroyCamera}.
+ * In Filament, Camera is a component that must be associated with an entity. To do so,
+ * use {@link Engine#createCamera(int)}. A Camera component is destroyed using
+ * {@link Engine#destroyCameraComponent(int Entity)} ()}.
  *
  * <pre>
- *  Engine engine = Engine.create();
- *
- *  Camera myCamera = engine.createCamera();
+ *  Camera myCamera = engine.createCamera(myCameraEntity);
  *  myCamera.setProjection(45, 16.0/9.0, 0.1, 1.0);
  *  myCamera.lookAt(0, 1.60, 1,
  *                  0, 0, 0,
  *                  0, 1, 0);
- *  engine.destroyCamera(myCamera);
+ *  engine.destroyCameraComponent(myCameraEntity);
  * </pre>
  *
  *
@@ -125,6 +121,9 @@ import androidx.annotation.Size;
 public class Camera {
     private long mNativeObject;
 
+    @Entity
+    private final int mEntity;
+
     /**
      * Denotes the projection type used by this camera.
      * @see #setProjection
@@ -147,8 +146,9 @@ public class Camera {
         HORIZONTAL
     }
 
-    Camera(long nativeCamera) {
+    Camera(long nativeCamera, @Entity int entity) {
         mNativeObject = nativeCamera;
+        mEntity = entity;
     }
 
     /**
@@ -252,9 +252,12 @@ public class Camera {
     }
 
     /**
-     * Sets the projection matrix.
+     * Sets a custom projection matrix.
      *
-     * @param inMatrix      custom projection matrix.
+     * <p>The projection matrix must define an NDC system that must match the OpenGL convention,
+     * that is all 3 axis are mapped to [-1, 1].</p>
+     *
+     * @param inProjection  custom projection matrix for rendering and culling
      *
      * @param near          distance in world units from the camera to the near plane.
      *                      The near plane's position in view space is z = -<code>near</code>.
@@ -270,10 +273,74 @@ public class Camera {
      *                      <code>far</code> != <code>near</code>
      *                              for {@link Projection#ORTHO}.
      */
-    public void setCustomProjection(@NonNull @Size(min = 16) double[] inMatrix,
+    public void setCustomProjection(@NonNull @Size(min = 16) double[] inProjection,
             double near, double far) {
-        Asserts.assertMat4dIn(inMatrix);
-        nSetCustomProjection(getNativeObject(), inMatrix, near, far);
+        Asserts.assertMat4dIn(inProjection);
+        nSetCustomProjection(getNativeObject(), inProjection, inProjection, near, far);
+    }
+
+    /**
+     * Sets a custom projection matrix.
+     *
+     * <p>The projection matrices must define an NDC system that must match the OpenGL convention,
+     * that is all 3 axis are mapped to [-1, 1].</p>
+     *
+     * @param inProjection              custom projection matrix for rendering.
+     *
+     * @param inProjectionForCulling    custom projection matrix for culling.
+     *
+     * @param near          distance in world units from the camera to the near plane.
+     *                      The near plane's position in view space is z = -<code>near</code>.
+     *                      Precondition:
+     *                      <code>near</code> > 0 for {@link Projection#PERSPECTIVE} or
+     *                      <code>near</code> != <code>far</code> for {@link Projection#ORTHO}.
+     *
+     * @param far           distance in world units from the camera to the far plane.
+     *                      The far plane's position in view space is z = -<code>far</code>.
+     *                      Precondition:
+     *                      <code>far</code> > <code>near</code>
+     *                              for {@link Projection#PERSPECTIVE} or
+     *                      <code>far</code> != <code>near</code>
+     *                              for {@link Projection#ORTHO}.
+     */
+    public void setCustomProjection(
+            @NonNull @Size(min = 16) double[] inProjection,
+            @NonNull @Size(min = 16) double[] inProjectionForCulling,
+            double near, double far) {
+        Asserts.assertMat4dIn(inProjection);
+        Asserts.assertMat4dIn(inProjectionForCulling);
+        nSetCustomProjection(getNativeObject(), inProjection, inProjectionForCulling, near, far);
+    }
+
+    /**
+     * Sets an additional matrix that scales the projection matrix.
+     *
+     * <p>This is useful to adjust the aspect ratio of the camera independent from its projection.
+     * First, pass an aspect of 1.0 to setProjection. Then set the scaling with the desired aspect
+     * ratio:<br>
+     *
+     * <code>
+     *     double aspect = width / height;
+     *
+     *     // with Fov.HORIZONTAL passed to setProjection:
+     *     camera.setScaling(1.0, aspect);
+     *
+     *     // with Fov.VERTICAL passed to setProjection:
+     *     camera.setScaling(1.0 / aspect, 1.0);
+     * </code>
+     *
+     * By default, this is an identity matrix.
+     * </p>
+     *
+     * @param xscaling  horizontal scaling to be applied after the projection matrix.
+     * @param yscaling  vertical scaling to be applied after the projection matrix.
+     *
+     * @see Camera#setProjection
+     * @see Camera#setLensProjection
+     * @see Camera#setCustomProjection
+     */
+    public void setScaling(double xscaling, double yscaling) {
+        nSetScaling(getNativeObject(), xscaling, yscaling);
     }
 
     /**
@@ -303,10 +370,33 @@ public class Camera {
      * @see Camera#setProjection
      * @see Camera#setLensProjection
      * @see Camera#setCustomProjection
+     *
+     * @deprecated use {@link #setScaling(double, double)}
+     *
      */
+    @Deprecated
     public void setScaling(@NonNull @Size(min = 4) double[] inScaling) {
         Asserts.assertDouble4In(inScaling);
-        nSetScaling(getNativeObject(), inScaling);
+        setScaling(inScaling[0], inScaling[1]);
+    }
+
+    /**
+     * Sets an additional matrix that shifts (translates) the projection matrix.
+     * <p>
+     * The shift parameters are specified in NDC coordinates, that is, if the translation must
+     * be specified in pixels, the xshift and yshift parameters be scaled by 1.0 / viewport.width
+     * and 1.0 / viewport.height respectively.
+     * </p>
+     *
+     * @param xshift    horizontal shift in NDC coordinates applied after the projection
+     * @param yshift    vertical shift in NDC coordinates applied after the projection
+     *
+     * @see Camera#setProjection
+     * @see Camera#setLensProjection
+     * @see Camera#setCustomProjection
+     */
+    public void setShift(double xshift, double yshift) {
+        nSetShift(getNativeObject(), xshift, yshift);
     }
 
     /**
@@ -329,6 +419,20 @@ public class Camera {
         nSetModelMatrix(getNativeObject(), viewMatrix);
     }
 
+    /**
+     * Sets the camera's view matrix.
+     * <p>
+     * Helper method to set the camera's entity transform component.
+     * Remember that the Camera "looks" towards its -z axis.
+     * <p>
+     *
+     * @param viewMatrix The camera position and orientation provided as a <b>rigid transform</b> matrix.
+     */
+    public void setModelMatrix(@NonNull @Size(min = 16) double[] viewMatrix) {
+        Asserts.assertMat4In(viewMatrix);
+        nSetModelMatrixFp64(getNativeObject(), viewMatrix);
+    }
+
     /**
      * Sets the camera's view matrix.
      *
@@ -348,6 +452,7 @@ public class Camera {
     }
 
     /**
+     * Gets the distance to the near plane
      * @return Distance to the near plane
      */
     public float getNear() {
@@ -355,6 +460,7 @@ public class Camera {
     }
 
     /**
+     * Gets the distance to the far plane
      * @return Distance to the far plane
      */
     public float getCullingFar() {
@@ -424,6 +530,22 @@ public class Camera {
         return out;
     }
 
+    /**
+     * Retrieves the camera's model matrix. The model matrix encodes the camera position and
+     * orientation, or pose.
+     *
+     * @param out A 16-double array where the model matrix will be stored, or null in which
+     *            case a new array is allocated.
+     *
+     * @return A 16-double array containing the camera's pose as a column-major matrix.
+     */
+    @NonNull @Size(min = 16)
+    public double[] getModelMatrix(@Nullable @Size(min = 16) double[] out) {
+        out = Asserts.assertMat4(out);
+        nGetModelMatrixFp64(getNativeObject(), out);
+        return out;
+    }
+
     /**
      * Retrieves the camera's view matrix. The view matrix is the inverse of the model matrix.
      *
@@ -439,6 +561,21 @@ public class Camera {
         return out;
     }
 
+    /**
+     * Retrieves the camera's view matrix. The view matrix is the inverse of the model matrix.
+     *
+     * @param out A 16-double array where the model view will be stored, or null in which
+     *            case a new array is allocated.
+     *
+     * @return A 16-double array containing the camera's view as a column-major matrix.
+     */
+    @NonNull @Size(min = 16)
+    public double[] getViewMatrix(@Nullable @Size(min = 16) double[] out) {
+        out = Asserts.assertMat4(out);
+        nGetViewMatrixFp64(getNativeObject(), out);
+        return out;
+    }
+
     /**
      * Retrieves the camera position in world space.
      *
@@ -551,6 +688,7 @@ public class Camera {
     }
 
     /**
+     * Gets the aperture in f-stops
      * @return Aperture in f-stops
      */
     public float getAperture() {
@@ -558,6 +696,7 @@ public class Camera {
     }
 
     /**
+     * Gets the shutter speed in seconds
      * @return Shutter speed in seconds
      */
     public float getShutterSpeed() {
@@ -565,12 +704,69 @@ public class Camera {
     }
 
     /**
+     * Gets the focal length in meters
+     * @return focal length in meters [m]
+     */
+    public double getFocalLength() {
+        return nGetFocalLength(getNativeObject());
+    }
+
+    /**
+     * Set the camera focus distance in world units
+     * @param distance Distance from the camera to the focus plane in world units. Must be
+     *                 positive and larger than the camera's near clipping plane.
+     */
+    public void setFocusDistance(float distance) {
+        nSetFocusDistance(getNativeObject(), distance);
+    }
+
+    /**
+     * Gets the distance from the camera to the focus plane in world units
+     * @return Distance from the camera to the focus plane in world units
+     */
+    public float getFocusDistance() {
+        return nGetFocusDistance(getNativeObject());
+    }
+
+    /**
+     * Gets the sensitivity in ISO
      * @return Sensitivity in ISO
      */
     public float getSensitivity() {
         return nGetSensitivity(getNativeObject());
     }
 
+    /**
+     * Gets the entity representing this Camera
+     * @return the entity this Camera component is attached to
+     */
+    @Entity
+    public int getEntity() {
+        return mEntity;
+    }
+
+    /**
+     * Helper to compute the effective focal length taking into account the focus distance
+     *
+     * @param focalLength       focal length in any unit (e.g. [m] or [mm])
+     * @param focusDistance     focus distance in same unit as focalLength
+     * @return                  the effective focal length in same unit as focalLength
+     */
+    static double computeEffectiveFocalLength(double focalLength, double focusDistance) {
+        return nComputeEffectiveFocalLength(focalLength, focusDistance);
+    }
+
+    /**
+     * Helper to compute the effective field-of-view taking into account the focus distance
+     *
+     * @param fovInDegrees      full field of view in degrees
+     * @param focusDistance     focus distance in meters [m]
+     * @return                  effective full field of view in degrees
+     */
+    static double computeEffectiveFov(double fovInDegrees, double focusDistance) {
+        return nComputeEffectiveFov(fovInDegrees, focusDistance);
+    }
+
     public long getNativeObject() {
         if (mNativeObject == 0) {
             throw new IllegalStateException("Calling method on destroyed Camera");
@@ -585,9 +781,11 @@ public class Camera {
     private static native void nSetProjection(long nativeCamera, int projection, double left, double right, double bottom, double top, double near, double far);
     private static native void nSetProjectionFov(long nativeCamera, double fovInDegrees, double aspect, double near, double far, int fov);
     private static native void nSetLensProjection(long nativeCamera, double focalLength, double aspect, double near, double far);
-    private static native void nSetCustomProjection(long nativeCamera, double[] inMatrix, double near, double far);
-    private static native void nSetScaling(long nativeCamera, double[] inScaling);
+    private static native void nSetCustomProjection(long nativeCamera, double[] inProjection, double[] inProjectionForCulling, double near, double far);
+    private static native void nSetScaling(long nativeCamera, double x, double y);
+    private static native void nSetShift(long nativeCamera, double x, double y);
     private static native void nSetModelMatrix(long nativeCamera, float[] in);
+    private static native void nSetModelMatrixFp64(long nativeCamera, double[] in);
     private static native void nLookAt(long nativeCamera, double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ);
     private static native float nGetNear(long nativeCamera);
     private static native float nGetCullingFar(long nativeCamera);
@@ -595,7 +793,9 @@ public class Camera {
     private static native void nGetCullingProjectionMatrix(long nativeCamera, double[] out);
     private static native void nGetScaling(long nativeCamera, double[] out);
     private static native void nGetModelMatrix(long nativeCamera, float[] out);
+    private static native void nGetModelMatrixFp64(long nativeCamera, double[] out);
     private static native void nGetViewMatrix(long nativeCamera, float[] out);
+    private static native void nGetViewMatrixFp64(long nativeCamera, double[] out);
     private static native void nGetPosition(long nativeCamera, float[] out);
     private static native void nGetLeftVector(long nativeCamera, float[] out);
     private static native void nGetUpVector(long nativeCamera, float[] out);
@@ -604,4 +804,9 @@ public class Camera {
     private static native float nGetAperture(long nativeCamera);
     private static native float nGetShutterSpeed(long nativeCamera);
     private static native float nGetSensitivity(long nativeCamera);
+    private static native void nSetFocusDistance(long nativeCamera, float distance);
+    private static native float nGetFocusDistance(long nativeCamera);
+    private static native double nGetFocalLength(long nativeCamera);
+    private static native double nComputeEffectiveFocalLength(double focalLength, double focusDistance);
+    private static native double nComputeEffectiveFov(double fovInDegrees, double focusDistance);
 }

android/filament-android/src/main/java/com/google/android/filament/ColorGrading.java

@@ -54,6 +54,8 @@ import static com.google.android.filament.Asserts.assertFloat4In;
  *
  * The various transforms held by ColorGrading are applied in the following order:
  * <ul>
+ * <li>Exposure</li>
+ * <li>Night adaptation</li>
  * <li>White balance</li>
  * <li>Channel mixer</li>
  * <li>Shadows/mid-tones/highlights</li>
@@ -63,12 +65,16 @@ import static com.google.android.filament.Asserts.assertFloat4In;
  * <li>Saturation</li>
  * <li>Curves</li>
  * <li>Tone mapping</li>
+ * <li>Luminance scaling</li>
+ * <li>Gamut mapping</li>
  * </ul>
  *
  * <h1>Defaults</h1>
  *
  * Here are the default color grading options:
  * <ul>
+ * <li>Exposure: 0.0</li>
+ * <li>Night adaptation: 0.0</li>
  * <li>White balance: temperature <code>0.0</code>, and tint <code>0.0</code></li>
  * <li>Channel mixer: red <code>{1,0,0}</code>, green <code>{0,1,0}</code>, blue <code>{0,0,1}</code></li>
  * <li>Shadows/mid-tones/highlights: shadows <code>{1,1,1,0}</code>, mid-tones <code>{1,1,1,0}</code>,
@@ -78,11 +84,13 @@ import static com.google.android.filament.Asserts.assertFloat4In;
  * <li>Vibrance: <code>1.0</code></li>
  * <li>Saturation: <code>1.0</code></li>
  * <li>Curves: gamma <code>{1,1,1}</code>, midPoint <code>{1,1,1}</code>, and scale <code>{1,1,1}</code></li>
- * <li>Tone mapping: {@link ToneMapping#ACES_LEGACY}</li>
+ * <li>Tone mapping: {@link ToneMapper.ACESLegacy}</li>
+ * <li>Luminance scaling: false</li>
+ * <li>Gamut mapping: false</li>
  * </ul>
  *
  * @see View
- * @see ToneMapping
+ * @see ToneMapper
  */
 public class ColorGrading {
     long mNativeObject;
@@ -99,6 +107,8 @@ public class ColorGrading {
 
     /**
      * List of available tone-mapping operators.
+     *
+     * @deprecated Use {@link ColorGrading.Builder#toneMapper(ToneMapper)}
      */
     public enum ToneMapping {
         /** Linear tone mapping (i.e. no tone mapping). */
@@ -109,15 +119,12 @@ public class ColorGrading {
         ACES,
         /** Filmic tone mapping, modelled after ACES but applied in sRGB space. */
         FILMIC,
-        /** Filmic tone mapping, with more contrast and saturation. */
-        UCHIMURA,
-        /** Reinhard luma-based tone mapping. */
-        REINHARD,
         /** Tone mapping used to validate/debug scene exposure. */
         DISPLAY_RANGE,
     }
 
-    ColorGrading(long colorGrading) {
+    // NOTE: This constructor is public only so that filament-utils can use it.
+    public ColorGrading(long colorGrading) {
         mNativeObject = colorGrading;
     }
 
@@ -155,6 +162,25 @@ public class ColorGrading {
             return this;
         }
 
+        /**
+         * Selects the tone mapping operator to apply to the HDR color buffer as the last
+         * operation of the color grading post-processing step.
+         *
+         * The default tone mapping operator is {@link ToneMapper.ACESLegacy}.
+         *
+         * The specified tone mapper must have a lifecycle that exceeds the lifetime of
+         * this builder. Since the build(Engine&) method is synchronous, it is safe to
+         * delete the tone mapper object after that finishes executing.
+         *
+         * @param toneMapper The tone mapping operator to apply to the HDR color buffer
+         *
+         * @return This Builder, for chaining calls
+         */
+        public Builder toneMapper(ToneMapper toneMapper) {
+            nBuilderToneMapper(mNativeBuilder, toneMapper.getNativeObject());
+            return this;
+        }
+
         /**
          * Selects the tone mapping operator to apply to the HDR color buffer as the last
          * operation of the color grading post-processing step.
@@ -164,12 +190,81 @@ public class ColorGrading {
          * @param toneMapping The tone mapping operator to apply to the HDR color buffer
          *
          * @return This Builder, for chaining calls
+         *
+         * @deprecated Use {@link #toneMapper(ToneMapper)}
          */
         public Builder toneMapping(ToneMapping toneMapping) {
             nBuilderToneMapping(mNativeBuilder, toneMapping.ordinal());
             return this;
         }
 
+        /**
+         * Enables or disables the luminance scaling component (LICH) from the exposure value
+         * invariant luminance system (EVILS). When this setting is enabled, pixels with high
+         * chromatic values will roll-off to white to offer a more natural rendering. This step
+         * also helps avoid undesirable hue skews caused by out of gamut colors clipped
+         * to the destination color gamut.
+         *
+         * When luminance scaling is enabled, tone mapping is performed on the luminance of each
+         * pixel instead of per-channel.
+         *
+         * @param luminanceScaling Enables or disables EVILS post-tone mapping
+         *
+         * @return This Builder, for chaining calls
+         */
+        public Builder luminanceScaling(boolean luminanceScaling) {
+            nBuilderLuminanceScaling(mNativeBuilder, luminanceScaling);
+            return this;
+        }
+
+        /**
+         * Enables or disables gamut mapping to the destination color space's gamut. When gamut
+         * mapping is turned off, out-of-gamut colors are clipped to the destination's gamut,
+         * which may produce hue skews (blue skewing to purple, green to yellow, etc.). When
+         * gamut mapping is enabled, out-of-gamut colors are brought back in gamut by trying to
+         * preserve the perceived chroma and lightness of the original values.
+         *
+         * @param gamutMapping Enables or disables gamut mapping
+         *
+         * @return This Builder, for chaining calls
+         */
+        public Builder gamutMapping(boolean gamutMapping) {
+            nBuilderGamutMapping(mNativeBuilder, gamutMapping);
+            return this;
+        }
+
+        /**
+         * Adjusts the exposure of this image. The exposure is specified in stops:
+         * each stop brightens (positive values) or darkens (negative values) the image by
+         * a factor of 2. This means that an exposure of 3 will brighten the image 8 times
+         * more than an exposure of 0 (2^3 = 8 and 2^0 = 1). Contrary to the camera's exposure,
+         * this setting is applied after all post-processing (bloom, etc.) are applied.
+         *
+         * @param exposure Value in EV stops. Can be negative, 0, or positive.
+         *
+         * @return This Builder, for chaining calls
+         */
+        public Builder exposure(float exposure) {
+            nBuilderExposure(mNativeBuilder, exposure);
+            return this;
+        }
+
+        /**
+         * Controls the amount of night adaptation to replicate a more natural representation of
+         * low-light conditions as perceived by the human vision system. In low-light conditions,
+         * peak luminance sensitivity of the eye shifts toward the blue end of the color spectrum:
+         * darker tones appear brighter, reducing contrast, and colors are blue shifted (the darker
+         * the more intense the effect).
+         *
+         * @param adaptation Amount of adaptation, between 0 (no adaptation) and 1 (full adaptation).
+         *
+         * @return This Builder, for chaining calls
+         */
+        public Builder nightAdaptation(float adaptation) {
+            nBuilderNightAdaptation(mNativeBuilder, adaptation);
+            return this;
+        }
+
         /**
          * Adjusts the while balance of the image. This can be used to remove color casts
          * and correct the appearance of the white point in the scene, or to alter the
@@ -270,7 +365,7 @@ public class ColorGrading {
          *
          * @return This Builder, for chaining calls
          */
-        Builder shadowsMidtonesHighlights(
+        public Builder shadowsMidtonesHighlights(
                 @NonNull @Size(min = 4) float[] shadows,
                 @NonNull @Size(min = 4) float[] midtones,
                 @NonNull @Size(min = 4) float[] highlights,
@@ -309,7 +404,7 @@ public class ColorGrading {
          *
          * @return This Builder, for chaining calls
          */
-        Builder slopeOffsetPower(
+        public Builder slopeOffsetPower(
                 @NonNull @Size(min = 3) float[] slope,
                 @NonNull @Size(min = 3) float[] offset,
                 @NonNull @Size(min = 3) float[] power) {
@@ -360,7 +455,7 @@ public class ColorGrading {
          *
          * @return This Builder, for chaining calls
          */
-        Builder vibrance(float vibrance) {
+        public Builder vibrance(float vibrance) {
             nBuilderVibrance(mNativeBuilder, vibrance);
             return this;
         }
@@ -462,7 +557,12 @@ public class ColorGrading {
     private static native void nDestroyBuilder(long nativeBuilder);
 
     private static native void nBuilderQuality(long nativeBuilder, int quality);
-    private static native void nBuilderToneMapping(long nativeBuilder, int toneMapper);
+    private static native void nBuilderToneMapper(long nativeBuilder, long toneMapper);
+    private static native void nBuilderToneMapping(long nativeBuilder, int toneMapping);
+    private static native void nBuilderLuminanceScaling(long nativeBuilder, boolean luminanceScaling);
+    private static native void nBuilderGamutMapping(long nativeBuilder, boolean gamutMapping);
+    private static native void nBuilderExposure(long nativeBuilder, float exposure);
+    private static native void nBuilderNightAdaptation(long nativeBuilder, float adaptation);
     private static native void nBuilderWhiteBalance(long nativeBuilder, float temperature, float tint);
     private static native void nBuilderChannelMixer(long nativeBuilder, float[] outRed, float[] outGreen, float[] outBlue);
     private static native void nBuilderShadowsMidtonesHighlights(long nativeBuilder, float[] shadows, float[] midtones, float[] highlights, float[] ranges);

android/filament-android/src/main/java/com/google/android/filament/Engine.java

@@ -106,10 +106,14 @@ import com.google.android.filament.proguard.UsedByReflection;
  * @see Renderer
  */
 public class Engine {
+    private static final Backend[] sBackendValues = Backend.values();
+
     private long mNativeObject;
+
     @NonNull private final TransformManager mTransformManager;
     @NonNull private final LightManager mLightManager;
     @NonNull private final RenderableManager mRenderableManager;
+    @NonNull private final EntityManager mEntityManager;
 
     /**
      * Denotes a backend
@@ -142,6 +146,7 @@ public class Engine {
         mTransformManager = new TransformManager(nGetTransformManager(nativeEngine));
         mLightManager = new LightManager(nGetLightManager(nativeEngine));
         mRenderableManager = new RenderableManager(nGetRenderableManager(nativeEngine));
+        mEntityManager = new EntityManager(nGetEntityManager(nativeEngine));
     }
 
     /**
@@ -250,7 +255,7 @@ public class Engine {
      */
     @NonNull
     public Backend getBackend() {
-        return Backend.values()[(int) nGetBackend(getNativeObject())];
+        return sBackendValues[(int) nGetBackend(getNativeObject())];
     }
 
     // SwapChain
@@ -397,19 +402,6 @@ public class Engine {
 
     // Camera
 
-    /**
-     * Creates a new <code>entity</code> and adds a {@link Camera} component to it.
-     *
-     * @return A newly created {@link Camera}
-     * @exception IllegalStateException can be thrown if the {@link Camera} couldn't be created
-     */
-    @NonNull
-    public Camera createCamera() {
-        long nativeCamera = nCreateCamera(getNativeObject());
-        if (nativeCamera == 0) throw new IllegalStateException("Couldn't create Camera");
-        return new Camera(nativeCamera);
-    }
-
     /**
      * Creates and adds a {@link Camera} component to a given <code>entity</code>.
      *
@@ -419,9 +411,9 @@ public class Engine {
      */
     @NonNull
     public Camera createCamera(@Entity int entity) {
-        long nativeCamera = nCreateCameraWithEntity(getNativeObject(), entity);
+        long nativeCamera = nCreateCamera(getNativeObject(), entity);
         if (nativeCamera == 0) throw new IllegalStateException("Couldn't create Camera");
-        return new Camera(nativeCamera);
+        return new Camera(nativeCamera, entity);
     }
 
     /**
@@ -435,16 +427,16 @@ public class Engine {
     public Camera getCameraComponent(@Entity int entity) {
         long nativeCamera = nGetCameraComponent(getNativeObject(), entity);
         if (nativeCamera == 0) return null;
-        return new Camera(nativeCamera);
+        return new Camera(nativeCamera, entity);
     }
 
     /**
-     * Destroys a {@link Camera} component and frees all its associated resources.
-     * @param camera the {@link Camera} to destroy
+     * Destroys the {@link Camera} component associated with the given entity.
+     *
+     * @param entity an entity
      */
-    public void destroyCamera(@NonNull Camera camera) {
-        nDestroyCamera(getNativeObject(), camera.getNativeObject());
-        camera.clearNativeObject();
+    public void destroyCameraComponent(@Entity int entity) {
+        nDestroyCameraComponent(getNativeObject(), entity);
     }
 
     // Scene
@@ -524,6 +516,15 @@ public class Engine {
         vertexBuffer.clearNativeObject();
     }
 
+    /**
+     * Destroys a {@link SkinningBuffer} and frees all its associated resources.
+     * @param skinningBuffer the {@link SkinningBuffer} to destroy
+     */
+    public void destroySkinningBuffer(@NonNull SkinningBuffer skinningBuffer) {
+        assertDestroy(nDestroySkinningBuffer(getNativeObject(), skinningBuffer.getNativeObject()));
+        skinningBuffer.clearNativeObject();
+    }
+
     /**
      * Destroys a {@link IndirectLight} and frees all its associated resources.
      * @param ibl the {@link IndirectLight} to destroy
@@ -568,7 +569,7 @@ public class Engine {
      * Destroys a {@link ColorGrading} and frees all its associated resources.
      * @param colorGrading the {@link ColorGrading} to destroy
      */
-    public void destroySkybox(@NonNull ColorGrading colorGrading) {
+    public void destroyColorGrading(@NonNull ColorGrading colorGrading) {
         assertDestroy(nDestroyColorGrading(getNativeObject(), colorGrading.getNativeObject()));
         colorGrading.clearNativeObject();
     }
@@ -632,9 +633,17 @@ public class Engine {
         return mRenderableManager;
     }
 
+    /**
+     * @return the {@link EntityManager} used by this {@link Engine}
+     */
+    @NonNull
+    public EntityManager getEntityManager() {
+        return mEntityManager;
+    }
+
     /**
      * Kicks the hardware thread (e.g.: the OpenGL, Vulkan or Metal thread) and blocks until
-     * all commands to this point are executed. Note that this doesn't guarantee that the
+     * all commands to this point are executed. Note that this does guarantee that the
      * hardware is actually finished.
      *
      * <p>This is typically used right after destroying the <code>SwapChain</code>,
@@ -654,13 +663,21 @@ public class Engine {
         return mNativeObject;
     }
 
+    @UsedByReflection("MaterialBuilder.java")
+    public long getNativeJobSystem() {
+        if (mNativeObject == 0) {
+            throw new IllegalStateException("Calling method on destroyed Engine");
+        }
+        return nGetJobSystem(getNativeObject());
+    }
+
     private void clearNativeObject() {
         mNativeObject = 0;
     }
 
     private static void assertDestroy(boolean success) {
         if (!success) {
-            throw new IllegalStateException("Object couldn't be destoyed (double destroy()?)");
+            throw new IllegalStateException("Object couldn't be destroyed (double destroy()?)");
         }
     }
 
@@ -675,10 +692,9 @@ public class Engine {
     private static native boolean nDestroyView(long nativeEngine, long nativeView);
     private static native long nCreateRenderer(long nativeEngine);
     private static native boolean nDestroyRenderer(long nativeEngine, long nativeRenderer);
-    private static native long nCreateCamera(long nativeEngine);
-    private static native long nCreateCameraWithEntity(long nativeEngine, int entity);
+    private static native long nCreateCamera(long nativeEngine, int entity);
     private static native long nGetCameraComponent(long nativeEngine, int entity);
-    private static native void nDestroyCamera(long nativeEngine, long nativeCamera);
+    private static native void nDestroyCameraComponent(long nativeEngine, int entity);
     private static native long nCreateScene(long nativeEngine);
     private static native boolean nDestroyScene(long nativeEngine, long nativeScene);
     private static native long nCreateFence(long nativeEngine);
@@ -686,6 +702,7 @@ public class Engine {
     private static native boolean nDestroyStream(long nativeEngine, long nativeStream);
     private static native boolean nDestroyIndexBuffer(long nativeEngine, long nativeIndexBuffer);
     private static native boolean nDestroyVertexBuffer(long nativeEngine, long nativeVertexBuffer);
+    private static native boolean nDestroySkinningBuffer(long nativeEngine, long nativeSkinningBuffer);
     private static native boolean nDestroyIndirectLight(long nativeEngine, long nativeIndirectLight);
     private static native boolean nDestroyMaterial(long nativeEngine, long nativeMaterial);
     private static native boolean nDestroyMaterialInstance(long nativeEngine, long nativeMaterialInstance);
@@ -698,4 +715,6 @@ public class Engine {
     private static native long nGetTransformManager(long nativeEngine);
     private static native long nGetLightManager(long nativeEngine);
     private static native long nGetRenderableManager(long nativeEngine);
+    private static native long nGetJobSystem(long nativeEngine);
+    private static native long nGetEntityManager(long nativeEngine);
 }

android/filament-android/src/main/java/com/google/android/filament/EntityManager.java

@@ -31,6 +31,10 @@ public class EntityManager {
     private EntityManager() {
     }
 
+    EntityManager(long nativeEntityManager) {
+        mNativeObject = nativeEntityManager;
+    }
+
     @NonNull
     public static EntityManager get() {
         return Holder.INSTANCE;

android/filament-android/src/main/java/com/google/android/filament/IndirectLight.java

@@ -21,8 +21,6 @@ import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.annotation.Size;
 
-import com.google.android.filament.proguard.UsedByReflection;
-
 /**
  * <code>IndirectLight</code> is used to simulate environment lighting, a form of global illumination.
  *
@@ -86,11 +84,7 @@ import com.google.android.filament.proguard.UsedByReflection;
 public class IndirectLight {
     long mNativeObject;
 
-    public IndirectLight(Engine engine, long indirectLight) {
-        mNativeObject = indirectLight;
-    }
-
-    IndirectLight(long indirectLight) {
+    public IndirectLight(long indirectLight) {
         mNativeObject = indirectLight;
     }
 
@@ -288,7 +282,7 @@ public class IndirectLight {
          * range can be adjusted with this method.</p>
          *
          * @param envIntensity  Scale factor applied to the environment and irradiance such that
-         *                      the result is in cd/m^2 (lux) units (default = 30000)
+         *                      the result is in <i>lux</i>, or <i>lumen/m^2</i> (default = 30000)
          *
          * @return This Builder, for chaining calls.
          */
@@ -354,14 +348,14 @@ public class IndirectLight {
      * range can be adjusted with this method.</p>
      *
      * @param intensity  Scale factor applied to the environment and irradiance such that
-     *                   the result is in cd/m^2 units (default = 30000)
+     *                   the result is in <i>lux</i>, or <i>lumen/m^2</i> (default = 30000)
      */
     public void setIntensity(float intensity) {
         nSetIntensity(getNativeObject(), intensity);
     }
 
     /**
-     * Returns the environment's intensity in cd/m<sup>2</sup>.
+     * Returns the environment's intensity in <i>lux</i>, or <i>lumen/m^2</i>.
      */
     public float getIntensity() {
         return nGetIntensity(getNativeObject());
@@ -430,6 +424,7 @@ public class IndirectLight {
     }
 
     /** @deprecated */
+    @Deprecated
     @NonNull @Size(min = 3)
     public float[] getDirectionEstimate(@Nullable @Size(min = 3) float[] direction) {
         direction = Asserts.assertFloat3(direction);
@@ -472,6 +467,7 @@ public class IndirectLight {
 
 
     /** @deprecated */
+    @Deprecated
     @NonNull @Size(min = 4)
     public float[] getColorEstimate(@Nullable @Size(min = 4) float[] colorIntensity, float x, float y, float z) {
         colorIntensity = Asserts.assertFloat4(colorIntensity);

android/filament-android/src/main/java/com/google/android/filament/LightManager.java

@@ -117,6 +117,8 @@ import androidx.annotation.Size;
  * </ul>
  */
 public class LightManager {
+    private static final Type[] sTypeValues = Type.values();
+
     private long mNativeObject;
 
     LightManager(long nativeLightManager) {
@@ -188,7 +190,7 @@ public class LightManager {
      * Control the quality / performance of the shadow map associated to this light
      */
     public static class ShadowOptions {
-        /** Size of the shadow map in texels. Must be a power-of-two. */
+        /** Size of the shadow map in texels. Must be a power-of-two and larger or equal to 8. */
         public int mapSize = 1024;
 
         /**
@@ -242,15 +244,17 @@ public class LightManager {
 
         /** Constant bias in world units (e.g. meters) by which shadows are moved away from the
          * light. 1mm by default.
+         * This is ignored when the View's ShadowType is set to VSM.
          */
-        public float constantBias = 0.05f;
+        public float constantBias = 0.001f;
 
         /** Amount by which the maximum sampling error is scaled. The resulting value is used
          * to move the shadow away from the fragment normal. Should be 1.0.
+         * This is ignored when the View's ShadowType is set to VSM.
          */
-        public float normalBias = 0.4f;
+        public float normalBias = 1.0f;
 
-        /** Distance from the camera after which shadows are clipped. this is used to clip
+        /** Distance from the camera after which shadows are clipped. This is used to clip
          * shadows that are too far and wouldn't contribute to the scene much, improving
          * performance and quality. This value is always positive.
          * Use 0.0f to use the camera far distance.
@@ -277,7 +281,24 @@ public class LightManager {
          * When set to true, all resolution enhancing features that can affect stability are
          * disabling, resulting in significantly lower resolution shadows, albeit stable ones.
          */
-        public boolean stable = true;
+        public boolean stable = false;
+
+        /**
+         * Constant bias in depth-resolution units by which shadows are moved away from the
+         * light. The default value of 0.5 is used to round depth values up.
+         * Generally this value shouldn't be changed or at least be small and positive.
+         * This is ignored when the View's ShadowType is set to VSM.
+         */
+        float polygonOffsetConstant = 0.5f;
+
+        /**
+         * Bias based on the change in depth in depth-resolution units by which shadows are moved
+         * away from the light. The default value of 2.0 works well with SHADOW_SAMPLING_PCF_LOW.
+         * Generally this value is between 0.5 and the size in texel of the PCF filter.
+         * Setting this value correctly is essential for LISPSM shadow-maps.
+         * This is ignored when the View's ShadowType is set to VSM.
+         */
+        float polygonOffsetSlope = 2.0f;
 
         /**
          * Whether screen-space contact shadows are used. This applies regardless of whether a
@@ -305,6 +326,37 @@ public class LightManager {
          *</p>
          */
         public float maxShadowDistance = 0.3f;
+
+        /*
+         * Options prefixed with 'vsm' are available when the View's ShadowType is set to VSM.
+         *
+         * @see View#setShadowType
+         */
+
+        /**
+         * The number of MSAA samples to use when rendering VSM shadow maps.
+         * Must be a power-of-two and greater than or equal to 1. A value of 1 effectively turns
+         * off MSAA.
+         * Higher values may not be available depending on the underlying hardware.
+         *
+         * <p>
+         * <strong>Warning: This API is still experimental and subject to change.</strong>
+         * </p>
+         */
+        @IntRange(from = 1)
+        public int vsmMsaaSamples = 1;
+
+        /**
+         * Blur width for the VSM blur. Zero do disable.
+         * The maximum value is 125.
+         */
+        public float blurWidth = 0.0f;
+
+        /**
+         * Light bulb radius used for soft shadows. Currently this is only used when DPCF is
+         * enabled. (2cm by default).
+         */
+        public float shadowBulbRadius = 0.02f;
     }
 
     public static class ShadowCascades {
@@ -403,6 +455,18 @@ public class LightManager {
             mFinalizer = new BuilderFinalizer(mNativeBuilder);
         }
 
+        /**
+         * Enables or disables a light channel. Light channel 0 is enabled by default.
+         *
+         * @param channel Light channel to enable or disable, between 0 and 7.
+         * @param enable Whether to enable or disable the light channel.
+         */
+        @NonNull
+        public Builder lightChannel(@IntRange(from = 0, to = 7) int channel, boolean enable) {
+            nBuilderLightChannel(mNativeBuilder, channel, enable);
+            return this;
+        }
+
         /**
          * Whether this Light casts shadows (disabled by default)
          *
@@ -432,8 +496,11 @@ public class LightManager {
             nBuilderShadowOptions(mNativeBuilder,
                     options.mapSize, options.shadowCascades, options.cascadeSplitPositions,
                     options.constantBias, options.normalBias, options.shadowFar, options.shadowNearHint,
-                    options.shadowFarHint, options.stable, options.screenSpaceContactShadows,
-                    options.stepCount, options.maxShadowDistance);
+                    options.shadowFarHint, options.stable,
+                    options.polygonOffsetConstant, options.polygonOffsetSlope,
+                    options.screenSpaceContactShadows,
+                    options.stepCount, options.maxShadowDistance, options.vsmMsaaSamples,
+                    options.blurWidth, options.shadowBulbRadius);
             return this;
         }
 
@@ -722,7 +789,7 @@ public class LightManager {
 
     @NonNull
     public Type getType(@EntityInstance int i) {
-        return Type.values()[nGetType(mNativeObject, i)];
+        return sTypeValues[nGetType(mNativeObject, i)];
     }
 
     /**
@@ -757,6 +824,30 @@ public class LightManager {
         return type == Type.SPOT || type == Type.FOCUSED_SPOT;
     }
 
+    /**
+     * Enables or disables a light channel.
+     * Light channel 0 is enabled by default.
+     *
+     * @param i        Instance of the component obtained from getInstance().
+     * @param channel  Light channel to set
+     * @param enable   true to enable, false to disable
+     *
+     * @see Builder#lightChannel
+     */
+    public void setLightChannel(@EntityInstance int i, @IntRange(from = 0, to = 7) int channel, boolean enable) {
+        nSetLightChannel(mNativeObject, i, channel, enable);
+    }
+
+    /**
+     * Returns whether a light channel is enabled on a specified renderable.
+     * @param i        Instance of the component obtained from getInstance().
+     * @param channel  Light channel to query
+     * @return         true if the light channel is enabled, false otherwise
+     */
+    public boolean getLightChannel(@EntityInstance int i, @IntRange(from = 0, to = 7) int channel) {
+        return nGetLightChannel(mNativeObject, i, channel);
+    }
+
     /**
      * Dynamically updates the light's position.
      *
@@ -1046,6 +1137,14 @@ public class LightManager {
         return nIsShadowCaster(mNativeObject, i);
     }
 
+    public float getOuterConeAngle(@EntityInstance int i) {
+        return nGetOuterConeAngle(mNativeObject, i);
+    }
+
+    public float getInnerConeAngle(@EntityInstance int i) {
+        return nGetInnerConeAngle(mNativeObject, i);
+    }
+
     public long getNativeObject() {
         return mNativeObject;
     }
@@ -1059,7 +1158,7 @@ public class LightManager {
     private static native void nDestroyBuilder(long nativeBuilder);
     private static native boolean nBuilderBuild(long nativeBuilder, long nativeEngine, int entity);
     private static native void nBuilderCastShadows(long nativeBuilder, boolean enable);
-    private static native void nBuilderShadowOptions(long nativeBuilder, int mapSize, int cascades, float[] splitPositions, float constantBias, float normalBias, float shadowFar, float shadowNearHint, float shadowFarhint, boolean stable, boolean screenSpaceContactShadows, int stepCount, float maxShadowDistance);
+    private static native void nBuilderShadowOptions(long nativeBuilder, int mapSize, int cascades, float[] splitPositions, float constantBias, float normalBias, float shadowFar, float shadowNearHint, float shadowFarhint, boolean stable, float polygonOffsetConstant, float polygonOffsetSlope, boolean screenSpaceContactShadows, int stepCount, float maxShadowDistance, int vsmMsaaSamples, float blurWidth, float shadowBulbRadius);
     private static native void nBuilderCastLight(long nativeBuilder, boolean enabled);
     private static native void nBuilderPosition(long nativeBuilder, float x, float y, float z);
     private static native void nBuilderDirection(long nativeBuilder, float x, float y, float z);
@@ -1072,6 +1171,7 @@ public class LightManager {
     private static native void nBuilderAngularRadius(long nativeBuilder, float angularRadius);
     private static native void nBuilderHaloSize(long nativeBuilder, float haloSize);
     private static native void nBuilderHaloFalloff(long nativeBuilder, float haloFalloff);
+    private static native void nBuilderLightChannel(long nativeBuilder, int channel, boolean enable);
 
     private static native void nComputeUniformSplits(float[] splitPositions, int cascades);
     private static native void nComputeLogSplits(float[] splitPositions, int cascades, float near, float far);
@@ -1099,4 +1199,8 @@ public class LightManager {
     private static native float nGetSunHaloFalloff(long nativeLightManager, int i);
     private static native void nSetShadowCaster(long nativeLightManager, int i, boolean shadowCaster);
     private static native boolean nIsShadowCaster(long nativeLightManager, int i);
+    private static native float nGetOuterConeAngle(long nativeLightManager, int i);
+    private static native float nGetInnerConeAngle(long nativeLightManager, int i);
+    private static native void nSetLightChannel(long nativeLightManager, int i, int channel, boolean enable);
+    private static native boolean nGetLightChannel(long nativeLightManager, int i, int channel);
 }

android/filament-android/src/main/java/com/google/android/filament/Material.java

@@ -37,6 +37,20 @@ import java.util.Set;
  * @see <a href="https://google.github.io/filament/Materials.html">Filament Materials Guide</a>
  */
 public class Material {
+    static final class EnumCache {
+        private EnumCache() { }
+
+        static final Shading[] sShadingValues = Shading.values();
+        static final Interpolation[] sInterpolationValues = Interpolation.values();
+        static final BlendingMode[] sBlendingModeValues = BlendingMode.values();
+        static final RefractionMode[] sRefractionModeValues = RefractionMode.values();
+        static final RefractionType[] sRefractionTypeValues = RefractionType.values();
+        static final VertexDomain[] sVertexDomainValues = VertexDomain.values();
+        static final CullingMode[] sCullingModeValues = CullingMode.values();
+        static final VertexBuffer.VertexAttribute[] sVertexAttributeValues =
+                VertexBuffer.VertexAttribute.values();
+    }
+
     private long mNativeObject;
     private final MaterialInstance mDefaultInstance;
 
@@ -210,6 +224,8 @@ public class Material {
 
     @UsedByNative("Material.cpp")
     public static class Parameter {
+        private static final Type[] sTypeValues = Type.values();
+
         public enum Type {
             BOOL,
             BOOL2,
@@ -233,7 +249,8 @@ public class Material {
             SAMPLER_2D_ARRAY,
             SAMPLER_CUBEMAP,
             SAMPLER_EXTERNAL,
-            SAMPLER_3D
+            SAMPLER_3D,
+            SUBPASS_INPUT
         }
 
         public enum Precision {
@@ -247,6 +264,10 @@ public class Material {
         @UsedByNative("Material.cpp")
         private static final int SAMPLER_OFFSET = Type.MAT4.ordinal() + 1;
 
+        @SuppressWarnings("unused")
+        @UsedByNative("Material.cpp")
+        private static final int SUBPASS_OFFSET = Type.SAMPLER_3D.ordinal() + 1;
+
         @NonNull
         public final String name;
         @NonNull
@@ -270,11 +291,11 @@ public class Material {
                 @IntRange(from = 0) int type, @IntRange(from = 0) int precision,
                 @IntRange(from = 1) int count) {
             parameters.add(
-                    new Parameter(name, Type.values()[type], Precision.values()[precision], count));
+                    new Parameter(name, sTypeValues[type], Precision.values()[precision], count));
         }
     }
 
-    Material(long nativeMaterial) {
+    public Material(long nativeMaterial) {
         mNativeObject = nativeMaterial;
         long nativeDefaultInstance = nGetDefaultInstance(nativeMaterial);
         mDefaultInstance = new MaterialInstance(this, nativeDefaultInstance);
@@ -368,7 +389,7 @@ public class Material {
      * Material Models</a>
      */
     public Shading getShading() {
-        return Shading.values()[nGetShading(getNativeObject())];
+        return EnumCache.sShadingValues[nGetShading(getNativeObject())];
     }
 
     /**
@@ -379,7 +400,7 @@ public class Material {
      * Vertex and attributes: interpolation</a>
      */
     public Interpolation getInterpolation() {
-        return Interpolation.values()[nGetInterpolation(getNativeObject())];
+        return EnumCache.sInterpolationValues[nGetInterpolation(getNativeObject())];
     }
 
     /**
@@ -390,7 +411,7 @@ public class Material {
      * Blending and transparency: blending</a>
      */
     public BlendingMode getBlendingMode() {
-        return BlendingMode.values()[nGetBlendingMode(getNativeObject())];
+        return EnumCache.sBlendingModeValues[nGetBlendingMode(getNativeObject())];
     }
 
     /**
@@ -401,7 +422,7 @@ public class Material {
      * Blending and transparency: refraction</a>
      */
     public RefractionMode getRefractionMode() {
-        return RefractionMode.values()[nGetRefractionMode(getNativeObject())];
+        return EnumCache.sRefractionModeValues[nGetRefractionMode(getNativeObject())];
     }
 
     /**
@@ -412,10 +433,9 @@ public class Material {
      * Blending and transparency: refractionType</a>
      */
     public RefractionType getRefractionType() {
-        return RefractionType.values()[nGetRefractionType(getNativeObject())];
+        return EnumCache.sRefractionTypeValues[nGetRefractionType(getNativeObject())];
     }
 
-
     /**
      * Returns the vertex domain of this material.
      *
@@ -424,7 +444,7 @@ public class Material {
      * Vertex and attributes: vertexDomain</a>
      */
     public VertexDomain getVertexDomain() {
-        return VertexDomain.values()[nGetVertexDomain(getNativeObject())];
+        return EnumCache.sVertexDomainValues[nGetVertexDomain(getNativeObject())];
     }
 
     /**
@@ -435,7 +455,7 @@ public class Material {
      * Rasterization: culling</a>
      */
     public CullingMode getCullingMode() {
-        return CullingMode.values()[nGetCullingMode(getNativeObject())];
+        return EnumCache.sCullingModeValues[nGetCullingMode(getNativeObject())];
     }
 
     /**
@@ -526,7 +546,7 @@ public class Material {
         if (mRequiredAttributes == null) {
             int bitSet = nGetRequiredAttributes(getNativeObject());
             mRequiredAttributes = EnumSet.noneOf(VertexBuffer.VertexAttribute.class);
-            VertexBuffer.VertexAttribute[] values = VertexBuffer.VertexAttribute.values();
+            VertexBuffer.VertexAttribute[] values = EnumCache.sVertexAttributeValues;
             for (int i = 0; i < values.length; i++) {
                 if ((bitSet & (1 << i)) != 0) {
                     mRequiredAttributes.add(values[i]);
@@ -755,7 +775,7 @@ public class Material {
      * @param name   name of the parameter array as defined by this Material
      * @param type   the number of components for each individual parameter
      * @param v      array of values to set to the named parameter array
-     * @param offset the number of elements to skip
+     * @param offset the number of elements in <code>v</code> to skip
      * @param count  the number of elements in the parameter array to set
      *
      * <p>For example, to set a parameter array of 4 bool4s:
@@ -763,11 +783,6 @@ public class Material {
      *     boolean[] a = new boolean[4 * 4];
      *     material.setDefaultParameter("param", MaterialInstance.BooleanElement.BOOL4, a, 0, 4);
      * }</pre>
-     * To only set the last 3 elements, specify an offset of 1 and a count of 3:
-     * <pre>{@code
-     *     boolean[] a = new boolean[4 * 3];
-     *     material.setDefaultParameter("param", MaterialInstance.BooleanElement.BOOL4, a, 1, 3);
-     * }</pre>
      * </p>
      *
      * @see Material#getDefaultInstance()
@@ -784,7 +799,7 @@ public class Material {
      * @param name   name of the parameter array as defined by this Material
      * @param type   the number of components for each individual parameter
      * @param v      array of values to set to the named parameter array
-     * @param offset the number of elements to skip
+     * @param offset the number of elements in <code>v</code> to skip
      * @param count  the number of elements in the parameter array to set
      *
      * <p>For example, to set a parameter array of 4 int4s:
@@ -792,11 +807,6 @@ public class Material {
      *     int[] a = new int[4 * 4];
      *     material.setDefaultParameter("param", MaterialInstance.IntElement.INT4, a, 0, 4);
      * }</pre>
-     * To only set the last 3 elements, specify an offset of 1 and a count of 3:
-     * <pre>{@code
-     *     int[] a = new int[4 * 3];
-     *     material.setDefaultParameter("param", MaterialInstance.IntElement.INT4, a, 1, 3);
-     * }</pre>
      * </p>
      *
      * @see Material#getDefaultInstance()
@@ -813,7 +823,7 @@ public class Material {
      * @param name   name of the parameter array as defined by this Material
      * @param type   the number of components for each individual parameter
      * @param v      array of values to set to the named parameter array
-     * @param offset the number of elements to skip
+     * @param offset the number of elements in <code>v</code> to skip
      * @param count  the number of elements in the parameter array to set
      *
      * <p>For example, to set a parameter array of 4 float4s:
@@ -821,11 +831,6 @@ public class Material {
      *     float[] a = new float[4 * 4];
      *     material.setDefaultParameter("param", MaterialInstance.FloatElement.FLOAT4, a, 0, 4);
      * }</pre>
-     * To only set the last 3 elements, specify an offset of 1 and a count of 3:
-     * <pre>{@code
-     *     float[] a = new float[4 * 3];
-     *     material.setDefaultParameter("param", MaterialInstance.FloatElement.FLOAT4, a, 1, 3);
-     * }</pre>
      * </p>
      *
      * @see Material#getDefaultInstance()

android/filament-android/src/main/java/com/google/android/filament/MaterialInstance.java

@@ -56,6 +56,7 @@ public class MaterialInstance {
 
     MaterialInstance(@NonNull Material material, long nativeMaterialInstance) {
         mMaterial = material;
+        mNativeMaterial = material.getNativeObject();
         mNativeObject = nativeMaterialInstance;
     }
 
@@ -64,6 +65,22 @@ public class MaterialInstance {
         mNativeMaterial = nGetMaterial(mNativeObject);
     }
 
+    /**
+     * Creates a new {@link #MaterialInstance} using another {@link #MaterialInstance} as a template for initialization.
+     * The new {@link #MaterialInstance} is an instance of the same {@link Material} of the template instance and
+     * must be destroyed just like any other {@link #MaterialInstance}.
+     *
+     * @param other A {@link #MaterialInstance} to use as a template for initializing a new instance
+     * @param name  A name for the new {@link #MaterialInstance} or nullptr to use the template's name
+     * @return      A new {@link #MaterialInstance}
+     */
+    @NonNull
+    public static MaterialInstance duplicate(@NonNull MaterialInstance other, String name) {
+        long nativeInstance = nDuplicate(other.mNativeObject, name);
+        if (nativeInstance == 0) throw new IllegalStateException("Couldn't duplicate MaterialInstance");
+        return new MaterialInstance(other.getMaterial(), nativeInstance);
+    }
+
     /** @return the {@link Material} associated with this instance */
     @NonNull
     public Material getMaterial() {
@@ -238,7 +255,7 @@ public class MaterialInstance {
      * @param name   name of the parameter array as defined by this Material
      * @param type   the number of components for each individual parameter
      * @param v      array of values to set to the named parameter array
-     * @param offset the number of elements to skip
+     * @param offset the number of elements in <code>v</code> to skip
      * @param count  the number of elements in the parameter array to set
      *
      * <p>For example, to set a parameter array of 4 bool4s:
@@ -246,11 +263,6 @@ public class MaterialInstance {
      *     boolean[] a = new boolean[4 * 4];
      *     instance.setParameter("param", MaterialInstance.BooleanElement.BOOL4, a, 0, 4);
      * }</pre>
-     * To only set the last 3 elements, specify an offset of 1 and a count of 3:
-     * <pre>{@code
-     *     boolean[] a = new boolean[4 * 3];
-     *     instance.setParameter("param", MaterialInstance.BooleanElement.BOOL4, a, 1, 3);
-     * }</pre>
      * </p>
      */
     public void setParameter(@NonNull String name,
@@ -265,7 +277,7 @@ public class MaterialInstance {
      * @param name   name of the parameter array as defined by this Material
      * @param type   the number of components for each individual parameter
      * @param v      array of values to set to the named parameter array
-     * @param offset the number of elements to skip
+     * @param offset the number of elements in <code>v</code> to skip
      * @param count  the number of elements in the parameter array to set
      *
      * <p>For example, to set a parameter array of 4 int4s:
@@ -273,11 +285,6 @@ public class MaterialInstance {
      *     int[] a = new int[4 * 4];
      *     instance.setParameter("param", MaterialInstance.IntElement.INT4, a, 0, 4);
      * }</pre>
-     * To only set the last 3 elements, specify an offset of 1 and a count of 3:
-     * <pre>{@code
-     *     int[] a = new int[4 * 3];
-     *     instance.setParameter("param", MaterialInstance.IntElement.INT4, a, 1, 3);
-     * }</pre>
      * </p>
      */
     public void setParameter(@NonNull String name,
@@ -292,7 +299,7 @@ public class MaterialInstance {
      * @param name   name of the parameter array as defined by this Material
      * @param type   the number of components for each individual parameter
      * @param v      array of values to set to the named parameter array
-     * @param offset the number of elements to skip
+     * @param offset the number of elements in <code>v</code> to skip
      * @param count  the number of elements in the parameter array to set
      *
      * <p>For example, to set a parameter array of 4 float4s:
@@ -300,11 +307,6 @@ public class MaterialInstance {
      *     float[] a = new float[4 * 4];
      *     material.setDefaultParameter("param", MaterialInstance.FloatElement.FLOAT4, a, 0, 4);
      * }</pre>
-     * To only set the last 3 elements, specify an offset of 1 and a count of 3:
-     * <pre>{@code
-     *     float[] a = new float[4 * 3];
-     *     material.setDefaultParameter("param", MaterialInstance.FloatElement.FLOAT4, a, 1, 3);
-     * }</pre>
      * </p>
      */
     public void setParameter(@NonNull String name,
@@ -452,7 +454,7 @@ public class MaterialInstance {
      * <a href="https://google.github.io/filament/Materials.html#materialdefinitions/materialblock/rasterization:colorWrite">
      * Rasterization: colorWrite</a>
      */
-    void setColorWrite(boolean enable) {
+    public void setColorWrite(boolean enable) {
         nSetColorWrite(getNativeObject(), enable);
     }
 
@@ -463,7 +465,7 @@ public class MaterialInstance {
      * <a href="https://google.github.io/filament/Materials.html#materialdefinitions/materialblock/rasterization:depthWrite">
      * Rasterization: depthWrite</a>
      */
-    void setDepthWrite(boolean enable) {
+    public void setDepthWrite(boolean enable) {
         nSetDepthWrite(getNativeObject(), enable);
     }
 
@@ -474,7 +476,7 @@ public class MaterialInstance {
      * <a href="https://google.github.io/filament/Materials.html#materialdefinitions/materialblock/rasterization:depthCulling">
      * Rasterization: depthCulling</a>
      */
-    void setDepthCulling(boolean enable) {
+    public void setDepthCulling(boolean enable) {
         nSetDepthCulling(getNativeObject(), enable);
     }
 
@@ -554,4 +556,6 @@ public class MaterialInstance {
 
     private static native String nGetName(long nativeMaterialInstance);
     private static native long nGetMaterial(long nativeMaterialInstance);
+
+    private static native long nDuplicate(long otherNativeMaterialInstance, String name);
 }

android/filament-android/src/main/java/com/google/android/filament/RenderTarget.java

@@ -31,13 +31,15 @@ import androidx.annotation.Nullable;
  * @see View
  */
 public class RenderTarget {
+    private static final int ATTACHMENT_COUNT = AttachmentPoint.values().length;
+    private static final Texture.CubemapFace[] sCubemapFaceValues = Texture.CubemapFace.values();
+
     private long mNativeObject;
-    private final Texture[] mTextures = new Texture[2];
+    private final Texture[] mTextures = new Texture[ATTACHMENT_COUNT];
 
     private RenderTarget(long nativeRenderTarget, Builder builder) {
         mNativeObject = nativeRenderTarget;
-        mTextures[0] = builder.mTextures[0];
-        mTextures[1] = builder.mTextures[1];
+        System.arraycopy(builder.mTextures, 0, mTextures, 0, ATTACHMENT_COUNT);
     }
 
     public long getNativeObject() {
@@ -52,7 +54,14 @@ public class RenderTarget {
      */
     public enum AttachmentPoint {
         COLOR,
-        DEPTH,
+        COLOR1,
+        COLOR2,
+        COLOR3,
+        COLOR4,
+        COLOR5,
+        COLOR6,
+        COLOR7,
+        DEPTH
     }
 
     /**
@@ -62,7 +71,7 @@ public class RenderTarget {
         @SuppressWarnings({"FieldCanBeLocal", "UnusedDeclaration"})
         private final BuilderFinalizer mFinalizer;
         private final long mNativeBuilder;
-        private final Texture[] mTextures = new Texture[2];
+        private final Texture[] mTextures = new Texture[ATTACHMENT_COUNT];
 
         public Builder() {
             mNativeBuilder = nCreateBuilder();
@@ -187,7 +196,7 @@ public class RenderTarget {
      * a cubemap.
      */
     public Texture.CubemapFace getFace(AttachmentPoint attachment) {
-        return Texture.CubemapFace.values()[nGetFace(getNativeObject(), attachment.ordinal())];
+        return sCubemapFaceValues[nGetFace(getNativeObject(), attachment.ordinal())];
     }
 
     /**

android/filament-android/src/main/java/com/google/android/filament/Renderer.java

@@ -107,12 +107,12 @@ public class Renderer {
         /**
          * Rate at which the scale will change to reach the target frame rate.
          */
-        public float scaleRate = 0.125f;
+        public float scaleRate = 1.0f / 15.0f;
 
         /**
-         * History size. higher values, tend to filter more (clamped to 30).
+         * History size. higher values, tend to filter more (clamped to 31).
          */
-        public int history = 9;
+        public int history = 15;
     }
 
     /**
@@ -309,13 +309,13 @@ public class Renderer {
      *
      * <p><code>render()</code> generates commands for each of the following stages:</p>
      * <ul>
-     * <li>Shadow map pass, if needed (currently only a single shadow map is supported)</li>
+     * <li>Shadow map passes, if needed</li>
      * <li>Depth pre-pass</li>
      * <li>SSAO pass, if enabled</li>
      * <li>Color pass</li>
      * <li>Post-processing pass</li>
      * </ul>
-     *
+     * <p>
      * A typical render loop looks like this:
      *
      * <pre>
@@ -331,31 +331,58 @@ public class Renderer {
      * </pre>
      *
      * <ul>
-     *<li><code>render()</code> must be called <b>after</b> {@link #beginFrame} and <b>before</b>
-     *{@link #endFrame}.</li>
+     * <li><code>render()</code> must be called <b>after</b> {@link #beginFrame} and <b>before</b>
+     * {@link #endFrame}.</li>
      *
-     *<li><code>render()</code> must be called from the {@link Engine}'s main thread
-     *(or external synchronization must be provided). In particular, calls to <code>render()</code>
-     *on different <code>Renderer</code> instances <b>must</b> be synchronized.</li>
+     * <li><code>render()</code> must be called from the {@link Engine}'s main thread
+     * (or external synchronization must be provided). In particular, calls to <code>render()</code>
+     * on different <code>Renderer</code> instances <b>must</b> be synchronized.</li>
      *
-     *<li><code>render()</code> performs potentially heavy computations and cannot be multi-threaded.
-     *However, internally, it is highly multi-threaded to both improve performance and mitigate
-     *the call's latency.</li>
+     * <li><code>render()</code> performs potentially heavy computations and cannot be multi-threaded.
+     * However, internally, it is highly multi-threaded to both improve performance and mitigate
+     * the call's latency.</li>
      *
-     *<li><code>render()</code> is typically called once per frame (but not necessarily).</li>
+     * <li><code>render()</code> is typically called once per frame (but not necessarily).</li>
      * </ul>
      *
      * @param view the {@link View} to render
-     *
      * @see #beginFrame
      * @see #endFrame
      * @see View
-     *
      */
     public void render(@NonNull View view) {
         nRender(getNativeObject(), view.getNativeObject());
     }
 
+    /**
+     * Renders a standalone {@link View} into its associated <code>RenderTarget</code>.
+     *
+     * <p>
+     * This call is mostly equivalent to calling {@link #render(View)} inside a
+     * {@link #beginFrame} / {@link #endFrame} block, but incurs less overhead. It can be used
+     * as a poor man's compute API. 
+     * </p>
+     *
+     * <ul>
+     * <li><code>renderStandaloneView()</code> must be called <b>outside</b> of
+     * {@link #beginFrame} / {@link #endFrame}.</li>
+     *
+     * <li><code>renderStandaloneView()</code> must be called from the {@link Engine}'s main thread
+     * (or external synchronization must be provided). In particular, calls to
+     * <code>renderStandaloneView()</code> on different <code>Renderer</code> instances <b>must</b>
+     * be synchronized.</li>
+     *
+     * <li><code>renderStandaloneView()</code> performs potentially heavy computations and cannot be
+     * multi-threaded. However, internally, it is highly multi-threaded to both improve performance
+     * and mitigate the call's latency.</li>
+     *
+     * @param view the {@link View} to render. This View must have an associated {@link RenderTarget}
+     * @see View
+     */
+    public void renderStandaloneView(@NonNull View view) {
+        nRenderStandaloneView(getNativeObject(), view.getNativeObject());
+    }
+
     /**
      * Copies the currently rendered {@link View} to the indicated {@link SwapChain}, using the
      * indicated source and destination rectangle.
@@ -410,8 +437,9 @@ public class Renderer {
      *</pre>
      *
      *
-     * <p>Typically <code>readPixels</code> will be called after {@link #render} and before
-     * {@link #endFrame}.</p>
+     * <p><code>readPixels</code> must be called within a frame, meaning after {@link #beginFrame}
+     * and before {@link #endFrame}. Typically, <code>readPixels</code> will be called after
+     * {@link #render}.</p>
      * <br>
      * <p>After calling this method, the callback associated with <code>buffer</code>
      * will be invoked on the main thread, indicating that the read-back has completed.
@@ -635,6 +663,7 @@ public class Renderer {
     private static native boolean nBeginFrame(long nativeRenderer, long nativeSwapChain, long frameTimeNanos);
     private static native void nEndFrame(long nativeRenderer);
     private static native void nRender(long nativeRenderer, long nativeView);
+    private static native void nRenderStandaloneView(long nativeRenderer, long nativeView);
     private static native void nCopyFrame(long nativeRenderer, long nativeDstSwapChain,
             int dstLeft, int dstBottom, int dstWidth, int dstHeight,
             int srcLeft, int srcBottom, int srcWidth, int srcHeight,

android/filament-android/src/main/java/com/google/android/filament/Scene.java

@@ -128,6 +128,7 @@ public class Scene {
     /**
      * @deprecated See {@link #removeEntity(int)}
      */
+    @Deprecated
     public void remove(@Entity int entity) {
         removeEntity(entity);
     }

android/filament-android/src/main/java/com/google/android/filament/SkinningBuffer.java

@@ -0,0 +1,177 @@
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.android.filament;
+
+import androidx.annotation.IntRange;
+import androidx.annotation.NonNull;
+
+import java.nio.Buffer;
+import java.nio.BufferOverflowException;
+import java.nio.FloatBuffer;
+
+public class SkinningBuffer {
+    private long mNativeObject;
+    private SkinningBuffer(long nativeSkinningBuffer) {
+        mNativeObject = nativeSkinningBuffer;
+    }
+
+    public static class Builder {
+        @SuppressWarnings({"FieldCanBeLocal", "UnusedDeclaration"})
+        // Keep to finalize native resources
+        private final SkinningBuffer.Builder.BuilderFinalizer mFinalizer;
+        private final long mNativeBuilder;
+
+        public Builder() {
+            mNativeBuilder = nCreateBuilder();
+            mFinalizer = new SkinningBuffer.Builder.BuilderFinalizer(mNativeBuilder);
+        }
+
+        /**
+         * Size of the skinning buffer in bones.
+         *
+         * <p>Due to limitation in the GLSL, the SkinningBuffer must always by a multiple of
+         * 256, this adjustment is done automatically, but can cause
+         * some memory overhead. This memory overhead can be mitigated by using the same
+         * {@link SkinningBuffer} to store the bone information for multiple RenderPrimitives.</p>
+         *
+         * @param boneCount Number of bones the skinning buffer can hold.
+         * @return this <code>Builder</code> object for chaining calls
+         */
+        @NonNull
+        public Builder boneCount(@IntRange(from = 1) int boneCount) {
+            nBuilderBoneCount(mNativeBuilder, boneCount);
+            return this;
+        }
+
+        /**
+         * The new buffer is created with identity bones
+         *
+         * @param initialize true to initializing the buffer, false to not.
+         * @return A reference to this Builder for chaining calls.
+         */
+        @NonNull
+        public Builder initialize(boolean initialize) {
+            nBuilderInitialize(mNativeBuilder, initialize);
+            return this;
+        }
+
+        /**
+         * Creates and returns the <code>SkinningBuffer</code> object.
+         *
+         * @param engine reference to the {@link Engine} to associate this <code>SkinningBuffer</code>
+         *               with.
+         *
+         * @return the newly created <code>SkinningBuffer</code> object
+         *
+         * @exception IllegalStateException if the SkinningBuffer could not be created
+         *
+         * @see #setBonesAsMatrices
+         * @see #setBonesAsQuaternions
+         */
+        @NonNull
+        public SkinningBuffer build(@NonNull Engine engine) {
+            long nativeSkinningBuffer = nBuilderBuild(mNativeBuilder, engine.getNativeObject());
+            if (nativeSkinningBuffer == 0)
+                throw new IllegalStateException("Couldn't create SkinningBuffer");
+            return new SkinningBuffer(nativeSkinningBuffer);
+        }
+
+        private static class BuilderFinalizer {
+            private final long mNativeObject;
+
+            BuilderFinalizer(long nativeObject) {
+                mNativeObject = nativeObject;
+            }
+
+            @Override
+            public void finalize() {
+                try {
+                    super.finalize();
+                } catch (Throwable t) { // Ignore
+                } finally {
+                    nDestroyBuilder(mNativeObject);
+                }
+            }
+        }
+    }
+
+    /**
+     * Updates the bone transforms in the range [offset, offset + boneCount).
+     *
+     * @param engine {@link Engine} instance
+     * @param matrices A {@link FloatBuffer} containing boneCount 4x4 packed matrices (i.e. 16 floats each matrix and no gap between matrices)
+     * @param boneCount Number of bones to set
+     * @param offset Index of the first bone to set
+     */
+    public void setBonesAsMatrices(@NonNull Engine engine,
+                                   @NonNull Buffer matrices, @IntRange(from = 0, to = 255) int boneCount,
+                                   @IntRange(from = 0) int offset) {
+        int result = nSetBonesAsMatrices(mNativeObject, engine.getNativeObject(),
+                matrices, matrices.remaining(), boneCount, offset);
+        if (result < 0) {
+            throw new BufferOverflowException();
+        }
+    }
+
+    /**
+     * Updates the bone transforms in the range [offset, offset + boneCount).
+     *
+     * @param engine {@link Engine} instance
+     * @param quaternions A {@link FloatBuffer} containing boneCount transforms. Each transform consists of 8 float.
+     *                    float 0 to 3 encode a unit quaternion <code>w+ix+jy+kz</code> stored as <code>x,y,z,w</code>.
+     *                    float 4 to 7 encode a translation stored as <code>x,y,z,1</code>.
+     * @param boneCount Number of bones to set
+     * @param offset Index of the first bone to set
+     */
+    public void setBonesAsQuaternions(@NonNull Engine engine,
+                                      @NonNull Buffer quaternions, @IntRange(from = 0, to = 255) int boneCount,
+                                      @IntRange(from = 0) int offset) {
+        int result = nSetBonesAsQuaternions(mNativeObject, engine.getNativeObject(),
+                quaternions, quaternions.remaining(), boneCount, offset);
+        if (result < 0) {
+            throw new BufferOverflowException();
+        }
+    }
+
+    /**
+     * @return number of bones in this {@link SkinningBuffer}
+     */
+    public int getBoneCount() {
+        return nGetBoneCount(mNativeObject);
+    }
+
+    public long getNativeObject() {
+        if (mNativeObject == 0) {
+            throw new IllegalStateException("Calling method on destroyed IndexBuffer");
+        }
+        return mNativeObject;
+    }
+
+    void clearNativeObject() {
+        mNativeObject = 0;
+    }
+
+    private static native long nCreateBuilder();
+    private static native void nDestroyBuilder(long nativeBuilder);
+    private static native void nBuilderBoneCount(long nativeBuilder, int boneCount);
+    private static native void nBuilderInitialize(long nativeBuilder, boolean initialize);
+    private static native long nBuilderBuild(long nativeBuilder, long nativeEngine);
+
+    private static native int nSetBonesAsMatrices(long nativeObject, long nativeEngine, Buffer matrices, int remaining, int boneCount, int offset);
+    private static native int nSetBonesAsQuaternions(long nativeObject, long nativeEngine, Buffer quaternions, int remaining, int boneCount, int offset);
+    private static native int nGetBoneCount(long nativeObject);
+}

android/filament-android/src/main/java/com/google/android/filament/Skybox.java

@@ -23,8 +23,6 @@ import androidx.annotation.Size;
 
 import static com.google.android.filament.Colors.LinearColor;
 
-import com.google.android.filament.proguard.UsedByReflection;
-
 /**
  * Skybox
  * <p>When added to a {@link Scene}, the <code>Skybox</code> fills all untouched pixels.</p>
@@ -53,11 +51,7 @@ import com.google.android.filament.proguard.UsedByReflection;
 public class Skybox {
     private long mNativeObject;
 
-    public Skybox(Engine engine, long nativeSkybox) {
-        mNativeObject = nativeSkybox;
-    }
-
-    Skybox(long nativeSkybox) {
+    public Skybox(long nativeSkybox) {
         mNativeObject = nativeSkybox;
     }
 
@@ -115,13 +109,14 @@ public class Skybox {
         }
 
         /**
-         * Sets the <code>Skybox</code> intensity when no {@link IndirectLight} is set
+         * Sets the <code>Skybox</code> intensity when no {@link IndirectLight} is set on the
+         * {@link Scene}.
          *
-         * <p>This call is ignored when an  {@link IndirectLight} is set, otherwise it is used in
-         * its place.</p>
+         * <p>This call is ignored when an {@link IndirectLight} is set on the {@link Scene}, and
+         * the intensity of the {@link IndirectLight} is used instead.</p>
          *
          * @param envIntensity  Scale factor applied to the skybox texel values such that
-         *                      the result is in cd/m<sup>2</sup> (lux) units (default = 30000)
+         *                      the result is in <i>lux</i>, or <i>lumen/m^2</i> (default = 30000)
          *
          * @return This Builder, for chaining calls.
          *
@@ -237,7 +232,7 @@ public class Skybox {
     }
 
     /**
-     * Returns the <code>Skybox</code>'s intensity in cd/m<sup>2</sup>.
+     * Returns the <code>Skybox</code>'s intensity in <i>lux</i>, or <i>lumen/m^2</i>.
      */
     public float getIntensity() { return nGetIntensity(getNativeObject()); }
 

android/filament-android/src/main/java/com/google/android/filament/Stream.java

@@ -26,10 +26,73 @@ import java.nio.ReadOnlyBufferException;
 /**
  * <code>Stream</code> is used to attach a native video stream to a filament {@link Texture}.
  *
+ * Stream supports three different configurations:
+ *
+ * <dl>
+ * <dt>TEXTURE_ID</dt>   <dd>takes an OpenGL texture ID and incurs a copy</dd>
+ * <dt>ACQUIRED</dt>     <dd>connects to an Android AHardwareBuffer</dd>
+ * <dt>NATIVE</dt>       <dd>connects to an Android SurfaceTexture</dd>
+ * </dl>
+ *
+ * <p>
+ * Before explaining these different configurations, let's review the high-level structure of an
+ * AR or video application that uses Filament.
+ * </p>
+ *
+ * <pre>
+ * while (true) {
+ *
+ *     // Misc application work occurs here, such as:
+ *     // - Writing the image data for a video frame into a Stream
+ *     // - Moving the Filament Camera
+ *
+ *     if (renderer.beginFrame(swapChain)) {
+ *         renderer.render(view);
+ *         renderer.endFrame();
+ *     }
+ * }
+ * </pre>
+ *
+ * <p>
+ * Let's say that the video image data at the time of a particular invocation of beginFrame
+ * becomes visible to users at time A. The 3D scene state (including the camera) at the time of
+ * that same invocation becomes apparent to users at time B.
+ * </p>
+ *
+ * <ul>
+ * <li>If time A matches time B, we say that the stream is <em>synchronized</em>.</li>
+ * <li>Filament invokes low-level graphics commands on the <em>driver thread</em>.</li>
+ * <li>The thread that calls beginFrame is called the <em>main thread</em>.</li>
+ * </ul>
+ *
+ * <p>
+ * The <b>TEXTURE_ID</b> configuration achieves synchronization automatically. In this mode,
+ * Filament performs a copy on the main thread during beginFrame by blitting the external image into
+ * an internal round-robin queue of images. This copy has a run-time cost.
+ * </p>
+ *
+ * <p>
+ * For <b>ACQUIRED</b> streams, there is no need to perform the copy because Filament explictly
+ * acquires the stream, then releases it later via a callback function. This configuration is
+ * especially useful when the Vulkan backend is enabled.
+ * </p>
+ *
+ * <p>
+ * For <b>NATIVE</b> streams, Filament does not make any synchronization guarantee. However they are
+ * simple to use and do not incur a copy. These are often appropriate in video applications.
+ * </p>
+ *
+ * <p>
+ * Please see <code>sample-stream-test</code> and <code>sample-hello-camera</code> for usage
+ * examples.
+ * </p>
+ *
  * @see Texture#setExternalStream
  * @see Engine#destroyStream
  */
 public class Stream {
+    private static final StreamType[] sStreamTypeValues = StreamType.values();
+
     private long mNativeObject;
     private long mNativeEngine;
 
@@ -105,7 +168,9 @@ public class Stream {
          *                          <code>GL_TEXTURE_EXTERNAL_OES.</code>
          * @return This Builder, for chaining calls.
          * @see Texture#setExternalStream
+         * @deprecated this method existed only for ARCore which doesn't need this anymore, use {@link Texture.Builder#importTexture(long)} instead.
          */
+        @Deprecated
         @NonNull
         public Builder stream(long externalTextureId) {
             nBuilderStream(mNativeBuilder, externalTextureId);
@@ -173,14 +238,23 @@ public class Stream {
      * Indicates whether this <code>Stream</code> is NATIVE, TEXTURE_ID, or ACQUIRED.
      */
     public StreamType getStreamType() {
-        return StreamType.values()[nGetStreamType(getNativeObject())];
+        return sStreamTypeValues[nGetStreamType(getNativeObject())];
     }
 
     /**
      * Updates an <pre>ACQUIRED</pre> stream with an image that is guaranteed to be used in the next frame.
      *
-     * This method should be called on the same thread that calls {#link Renderer#beginFrame}, which is
-     * also where the callback is invoked.
+     * This method tells Filament to immediately "acquire" the image and trigger a callback
+     * when it is done with it. This should be called by the user outside of beginFrame / endFrame,
+     * and should be called only once per frame. If the user pushes images to the same stream
+     * multiple times in a single frame, only the final image is honored, but all callbacks are
+     * invoked.
+     *
+     * This method should be called on the same thread that calls {@link Renderer#beginFrame}, which is
+     * also where the callback is invoked. This method can only be used for streams that were
+     * constructed without calling the {@link Builder.stream} method.
+     *
+     * See {@link Stream} for more information about NATIVE, TEXTURE_ID, and ACQUIRED configurations.
      *
      * @param hwbuffer {@link android.hardware.HardwareBuffer HardwareBuffer} (requires API level 26)
      * @param handler {@link java.util.concurrent.Executor Executor} or {@link android.os.Handler Handler}.

android/filament-android/src/main/java/com/google/android/filament/SwapChain.java

@@ -85,6 +85,12 @@ public class SwapChain {
      */
     public static final long CONFIG_READABLE = 0x2;
 
+    /**
+     * Indicates that the native X11 window is an XCB window rather than an XLIB window.
+     * This is ignored on non-Linux platforms and in builds that support only one X11 API.
+     */
+    public static final long CONFIG_ENABLE_XCB = 0x4;
+
     SwapChain(long nativeSwapChain, Object surface) {
         mNativeObject = nativeSwapChain;
         mSurface = surface;
@@ -98,6 +104,31 @@ public class SwapChain {
         return mSurface;
     }
 
+    /**
+     * FrameCompletedCallback is a callback function that notifies an application when a frame's
+     * contents have completed rendering on the GPU.
+     *
+     * <p>
+     * Use setFrameCompletedCallback to set a callback on an individual SwapChain. Each time a frame
+     * completes GPU rendering, the callback will be called.
+     * </p>
+     *
+     * <p>
+     * The FrameCompletedCallback is guaranteed to be called on the main Filament thread.
+     * </p>
+     *
+     * <p>
+     * Warning: Only Filament's Metal backend supports frame callbacks. Other backends ignore the
+     * callback (which will never be called) and proceed normally.
+     * </p>
+     *
+     * @param handler     A {@link java.util.concurrent.Executor Executor}.
+     * @param callback    The Runnable callback to invoke.
+     */
+    public void setFrameCompletedCallback(@NonNull Object handler, @NonNull Runnable callback) {
+        nSetFrameCompletedCallback(getNativeObject(), handler, callback);
+    }
+
     public long getNativeObject() {
         if (mNativeObject == 0) {
             throw new IllegalStateException("Calling method on destroyed SwapChain");
@@ -108,4 +139,6 @@ public class SwapChain {
     void clearNativeObject() {
         mNativeObject = 0;
     }
+
+    private static native void nSetFrameCompletedCallback(long nativeSwapChain, Object handler, Runnable callback);
 }

android/filament-android/src/main/java/com/google/android/filament/Texture.java

@@ -71,13 +71,12 @@ import static com.google.android.filament.Texture.Type.COMPRESSED;
  * @see MaterialInstance#setParameter(String, Texture, TextureSampler)
  */
 public class Texture {
+    private static final Sampler[] sSamplerValues = Sampler.values();
+    private static final InternalFormat[] sInternalFormatValues = InternalFormat.values();
+
     private long mNativeObject;
 
-    Texture(long nativeTexture) {
-        mNativeObject = nativeTexture;
-    }
-
-    public Texture(Engine engine, long nativeTexture) {
+    public Texture(long nativeTexture) {
         mNativeObject = nativeTexture;
     }
 
@@ -220,7 +219,38 @@ public class Texture {
         ETC2_EAC_RGBA8, ETC2_EAC_SRGBA8,
 
         // Available everywhere except Android/iOS
-        DXT1_RGB, DXT1_RGBA, DXT3_RGBA, DXT5_RGBA
+        DXT1_RGB, DXT1_RGBA, DXT3_RGBA, DXT5_RGBA,
+        DXT1_SRGB, DXT1_SRGBA, DXT3_SRGBA, DXT5_SRGBA,
+
+        // ASTC formats are available with a GLES extension
+        RGBA_ASTC_4x4,
+        RGBA_ASTC_5x4,
+        RGBA_ASTC_5x5,
+        RGBA_ASTC_6x5,
+        RGBA_ASTC_6x6,
+        RGBA_ASTC_8x5,
+        RGBA_ASTC_8x6,
+        RGBA_ASTC_8x8,
+        RGBA_ASTC_10x5,
+        RGBA_ASTC_10x6,
+        RGBA_ASTC_10x8,
+        RGBA_ASTC_10x10,
+        RGBA_ASTC_12x10,
+        RGBA_ASTC_12x12,
+        SRGB8_ALPHA8_ASTC_4x4,
+        SRGB8_ALPHA8_ASTC_5x4,
+        SRGB8_ALPHA8_ASTC_5x5,
+        SRGB8_ALPHA8_ASTC_6x5,
+        SRGB8_ALPHA8_ASTC_6x6,
+        SRGB8_ALPHA8_ASTC_8x5,
+        SRGB8_ALPHA8_ASTC_8x6,
+        SRGB8_ALPHA8_ASTC_8x8,
+        SRGB8_ALPHA8_ASTC_10x5,
+        SRGB8_ALPHA8_ASTC_10x6,
+        SRGB8_ALPHA8_ASTC_10x8,
+        SRGB8_ALPHA8_ASTC_10x10,
+        SRGB8_ALPHA8_ASTC_12x10,
+        SRGB8_ALPHA8_ASTC_12x12
     }
 
     /**
@@ -235,7 +265,38 @@ public class Texture {
         ETC2_EAC_RGBA8, ETC2_EAC_SRGBA8,
 
         // Available everywhere except Android/iOS
-        DXT1_RGB, DXT1_RGBA, DXT3_RGBA, DXT5_RGBA
+        DXT1_RGB, DXT1_RGBA, DXT3_RGBA, DXT5_RGBA,
+        DXT1_SRGB, DXT1_SRGBA, DXT3_SRGBA, DXT5_SRGBA,
+
+        // ASTC formats are available with a GLES extension
+        RGBA_ASTC_4x4,
+        RGBA_ASTC_5x4,
+        RGBA_ASTC_5x5,
+        RGBA_ASTC_6x5,
+        RGBA_ASTC_6x6,
+        RGBA_ASTC_8x5,
+        RGBA_ASTC_8x6,
+        RGBA_ASTC_8x8,
+        RGBA_ASTC_10x5,
+        RGBA_ASTC_10x6,
+        RGBA_ASTC_10x8,
+        RGBA_ASTC_10x10,
+        RGBA_ASTC_12x10,
+        RGBA_ASTC_12x12,
+        SRGB8_ALPHA8_ASTC_4x4,
+        SRGB8_ALPHA8_ASTC_5x4,
+        SRGB8_ALPHA8_ASTC_5x5,
+        SRGB8_ALPHA8_ASTC_6x5,
+        SRGB8_ALPHA8_ASTC_6x6,
+        SRGB8_ALPHA8_ASTC_8x5,
+        SRGB8_ALPHA8_ASTC_8x6,
+        SRGB8_ALPHA8_ASTC_8x8,
+        SRGB8_ALPHA8_ASTC_10x5,
+        SRGB8_ALPHA8_ASTC_10x6,
+        SRGB8_ALPHA8_ASTC_10x8,
+        SRGB8_ALPHA8_ASTC_10x10,
+        SRGB8_ALPHA8_ASTC_12x10,
+        SRGB8_ALPHA8_ASTC_12x12
     }
 
     /**
@@ -509,12 +570,15 @@ public class Texture {
                 case RGBA_INTEGER:
                     n = 4;
                     break;
+
+                default: throw new IllegalStateException("unsupported format enum");
             }
 
             int bpp = n;
             switch (type) {
                 case UBYTE:
                 case BYTE:
+                case COMPRESSED:
                     // nothing to do
                     break;
                 case USHORT:
@@ -531,6 +595,9 @@ public class Texture {
                     // Special case, format must be RGB and uses 4 bytes
                     bpp = 4;
                     break;
+                case USHORT_565:
+                    bpp = 2;
+                    break;
             }
 
             int bpr = bpp * stride;
@@ -562,6 +629,17 @@ public class Texture {
         return nIsTextureFormatSupported(engine.getNativeObject(), format.ordinal());
     }
 
+    /**
+     * Checks whether texture swizzling is supported in this {@link Engine}.
+     * This depends on the selected backend.
+     *
+     * @param engine {@link Engine}
+     * @return <code>true</code> if texture swizzling.
+     */
+    public static boolean isTextureSwizzleSupported(@NonNull Engine engine) {
+        return nIsTextureSwizzleSupported(engine.getNativeObject());
+    }
+
     /**
      * Use <code>Builder</code> to construct a <code>Texture</code> object instance.
      */
@@ -678,6 +756,26 @@ public class Texture {
             return this;
         }
 
+        /**
+         * Specify a native texture to import as a Filament texture.
+         * <p>
+         * The texture id is backend-specific:
+         * <ul>
+         *   <li> OpenGL: GLuint texture ID </li>
+         * </ul>
+         * </p>
+         *
+         *
+         * @param id a backend specific texture identifier
+         *
+         * @return This Builder, for chaining calls.
+         */
+        @NonNull
+        public Builder importTexture(long id) {
+            nBuilderImportTexture(mNativeBuilder, id);
+            return this;
+        }
+
         /**
          * Creates a new <code>Texture</code> instance.
          * @param engine The {@link Engine} to associate this <code>Texture</code> with.
@@ -772,7 +870,7 @@ public class Texture {
      */
     @NonNull
     public Sampler getTarget() {
-        return Sampler.values()[nGetTarget(getNativeObject())];
+        return sSamplerValues[nGetTarget(getNativeObject())];
     }
 
     /**
@@ -780,7 +878,7 @@ public class Texture {
      */
     @NonNull
     public InternalFormat getFormat() {
-        return InternalFormat.values()[nGetInternalFormat(getNativeObject())];
+        return sInternalFormatValues[nGetInternalFormat(getNativeObject())];
     }
 
     // TODO: add a setImage() version that takes an android Bitmap
@@ -882,7 +980,7 @@ public class Texture {
      * @param level     Level to set the image for. Must be less than {@link #getLevels()}.
      * @param xoffset   x-offset in texel of the region to modify
      * @param yoffset   y-offset in texel of the region to modify
-     * @param yoffset   z-offset in texel of the region to modify
+     * @param zoffset   z-offset in texel of the region to modify
      * @param width     width in texel of the region to modify
      * @param height    height in texel of the region to modify
      * @param depth     depth in texel or index of the region to modify
@@ -1137,6 +1235,7 @@ public class Texture {
     }
 
     private static native boolean nIsTextureFormatSupported(long nativeEngine, int internalFormat);
+    private static native boolean nIsTextureSwizzleSupported(long nativeEngine);
 
     private static native long nCreateBuilder();
     private static native void nDestroyBuilder(long nativeBuilder);
@@ -1149,6 +1248,7 @@ public class Texture {
     private static native void nBuilderFormat(long nativeBuilder, int format);
     private static native void nBuilderUsage(long nativeBuilder, int flags);
     private static native void nBuilderSwizzle(long nativeBuilder, int r, int g, int b, int a);
+    private static native void nBuilderImportTexture(long nativeBuilder, long id);
     private static native long nBuilderBuild(long nativeBuilder, long nativeEngine);
 
     private static native int nGetWidth(long nativeTexture, int level);
@@ -1160,35 +1260,35 @@ public class Texture {
 
     private static native int nSetImage(long nativeTexture, long nativeEngine,
             int level, int xoffset, int yoffset, int width, int height,
-            Buffer storage, int remaining, int left, int bottom, int type, int alignment,
+            Buffer storage, int remaining, int left, int top, int type, int alignment,
             int stride, int format,
             Object handler, Runnable callback);
 
     private static native int nSetImageCompressed(long nativeTexture, long nativeEngine,
             int level, int xoffset, int yoffset, int width, int height,
-            Buffer storage, int remaining, int left, int bottom, int type, int alignment,
+            Buffer storage, int remaining, int left, int top, int type, int alignment,
             int compressedSizeInBytes, int compressedFormat,
             Object handler, Runnable callback);
 
     private static native int nSetImage3D(long nativeTexture, long nativeEngine,
             int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth,
-            Buffer storage, int remaining, int left, int bottom, int type, int alignment,
+            Buffer storage, int remaining, int left, int top, int type, int alignment,
             int stride, int format,
             Object handler, Runnable callback);
 
     private static native int nSetImage3DCompressed(long nativeTexture, long nativeEngine,
             int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth,
-            Buffer storage, int remaining, int left, int bottom, int type, int alignment,
+            Buffer storage, int remaining, int left, int top, int type, int alignment,
             int compressedSizeInBytes, int compressedFormat,
             Object handler, Runnable callback);
 
     private static native int nSetImageCubemap(long nativeTexture, long nativeEngine,
-            int level, Buffer storage, int remaining, int left, int bottom, int type,
+            int level, Buffer storage, int remaining, int left, int top, int type,
             int alignment, int stride, int format,
             int[] faceOffsetsInBytes, Object handler, Runnable callback);
 
     private static native int nSetImageCubemapCompressed(long nativeTexture, long nativeEngine,
-            int level, Buffer storage, int remaining, int left, int bottom, int type,
+            int level, Buffer storage, int remaining, int left, int top, int type,
             int alignment, int compressedSizeInBytes, int compressedFormat,
             int[] faceOffsetsInBytes, Object handler, Runnable callback);
 

android/filament-android/src/main/java/com/google/android/filament/TextureSampler.java

@@ -22,6 +22,14 @@ import androidx.annotation.NonNull;
  * <code>TextureSampler</code> defines how a texture is accessed.
  */
 public class TextureSampler {
+    static final class EnumCache {
+        static final MinFilter[] sMinFilterValues = MinFilter.values();
+        static final MagFilter[] sMagFilterValues = MagFilter.values();
+        static final WrapMode[] sWrapModeValues = WrapMode.values();
+        static final CompareMode[] sCompareModeValues = CompareMode.values();
+        static final CompareFunction[] sCompareFunctionValues = CompareFunction.values();
+    }
+
     public enum WrapMode {
         /**
          * The edge of the texture extends to infinity.
@@ -202,7 +210,7 @@ public class TextureSampler {
      * @return the minification filter
      */
     public MinFilter getMinFilter() {
-        return MinFilter.values()[nGetMinFilter(mSampler)];
+        return EnumCache.sMinFilterValues[nGetMinFilter(mSampler)];
     }
 
     /**
@@ -218,7 +226,7 @@ public class TextureSampler {
      * @return the magnification filter
      */
     public MagFilter getMagFilter() {
-        return MagFilter.values()[nGetMagFilter(mSampler)];
+        return EnumCache.sMagFilterValues[nGetMagFilter(mSampler)];
     }
 
     /**
@@ -234,7 +242,7 @@ public class TextureSampler {
      * @return the wrapping mode in the s (horizontal) direction
      */
     public WrapMode getWrapModeS() {
-        return WrapMode.values()[nGetWrapModeS(mSampler)];
+        return EnumCache.sWrapModeValues[nGetWrapModeS(mSampler)];
     }
 
     /**
@@ -249,7 +257,7 @@ public class TextureSampler {
      * @return the wrapping mode in the t (vertical) direction
      */
     public WrapMode getWrapModeT() {
-        return WrapMode.values()[nGetWrapModeT(mSampler)];
+        return EnumCache.sWrapModeValues[nGetWrapModeT(mSampler)];
     }
 
     /**
@@ -264,7 +272,7 @@ public class TextureSampler {
      * @return the wrapping mode in the r (depth) direction
      */
     public WrapMode getWrapModeR() {
-        return WrapMode.values()[nGetWrapModeR(mSampler)];
+        return EnumCache.sWrapModeValues[nGetWrapModeR(mSampler)];
     }
 
     /**
@@ -297,7 +305,7 @@ public class TextureSampler {
      * @return the comparison mode
      */
     public CompareMode getCompareMode() {
-        return CompareMode.values()[nGetCompareMode(mSampler)];
+        return EnumCache.sCompareModeValues[nGetCompareMode(mSampler)];
     }
 
     /**
@@ -313,7 +321,7 @@ public class TextureSampler {
      * @return the comparison function
      */
     public CompareFunction getCompareFunction() {
-        return CompareFunction.values()[nGetCompareFunction(mSampler)];
+        return EnumCache.sCompareFunctionValues[nGetCompareFunction(mSampler)];
     }
 
     /**

android/filament-android/src/main/java/com/google/android/filament/ToneMapper.java

@@ -0,0 +1,210 @@
+package com.google.android.filament;
+
+/**
+ * Interface for tone mapping operators. A tone mapping operator, or tone mapper,
+ * is responsible for compressing the dynamic range of the rendered scene to a
+ * dynamic range suitable for display.
+ *
+ * In Filament, tone mapping is a color grading step. ToneMapper instances are
+ * created and passed to the ColorGrading::Builder to produce a 3D LUT that will
+ * be used during post-processing to prepare the final color buffer for display.
+ *
+ * Filament provides several default tone mapping operators that fall into three
+ * categories:
+ *
+ * <ul>
+ * <li>Configurable tone mapping operators</li>
+ * <ul>
+ *   <li>GenericToneMapper</li>
+ * </ul>
+ * <li>Fixed-aesthetic tone mapping operators</li>
+ * <ul>
+ *   <li>ACESToneMapper</li>
+ *   <li>ACESLegacyToneMapper</li>
+ *   <li>FilmicToneMapper</li>
+ * </ul>
+ * <li>Debug/validation tone mapping operators</li>
+ * <ul>
+ *   <li>LinearToneMapper</li>
+ *   <li>DisplayRangeToneMapper</li>
+ * </ul>
+ * </ul>
+ *
+ * You can create custom tone mapping operators by subclassing ToneMapper.
+ */
+public class ToneMapper {
+    private final long mNativeObject;
+
+    private ToneMapper(long nativeObject) {
+        mNativeObject = nativeObject;
+    }
+
+    public long getNativeObject() {
+        if (mNativeObject == 0) {
+            throw new IllegalStateException("Calling method on destroyed ToneMapper");
+        }
+        return mNativeObject;
+    }
+
+    @Override
+    protected void finalize() throws Throwable {
+        try {
+            super.finalize();
+        } finally {
+            nDestroyToneMapper(mNativeObject);
+        }
+    }
+
+    /**
+     * Linear tone mapping operator that returns the input color but clamped to
+     * the 0..1 range. This operator is mostly useful for debugging.
+     */
+    public static class Linear extends ToneMapper {
+        public Linear() {
+            super(nCreateLinearToneMapper());
+        }
+    }
+
+    /**
+     * ACES tone mapping operator. This operator is an implementation of the
+     * ACES Reference Rendering Transform (RRT) combined with the Output Device
+     * Transform (ODT) for sRGB monitors (dim surround, 100 nits).
+     */
+    public static class ACES extends ToneMapper {
+        public ACES() {
+            super(nCreateACESToneMapper());
+        }
+    }
+
+    /**
+     * ACES tone mapping operator, modified to match the perceived brightness
+     * of FilmicToneMapper. This operator is the same as ACESToneMapper but
+     * applies a brightness multiplier of ~1.6 to the input color value to
+     * target brighter viewing environments.
+     */
+    public static class ACESLegacy extends ToneMapper {
+        public ACESLegacy() {
+            super(nCreateACESLegacyToneMapper());
+        }
+    }
+
+    /**
+     * "Filmic" tone mapping operator. This tone mapper was designed to
+     * approximate the aesthetics of the ACES RRT + ODT for Rec.709
+     * and historically Filament's default tone mapping operator. It exists
+     * only for backward compatibility purposes and is not otherwise recommended.
+     */
+    public static class Filmic extends ToneMapper {
+        public Filmic() {
+            super(nCreateFilmicToneMapper());
+        }
+    }
+
+    /**
+     * Generic tone mapping operator that gives control over the tone mapping
+     * curve. This operator can be used to control the aesthetics of the final
+     * image. This operator also allows to control the dynamic range of the
+     * scene referred values.
+     *
+     * The tone mapping curve is defined by 5 parameters:
+     * <ul>
+     * <li>contrast: controls the contrast of the curve</li>
+     * referred values map to output white</li>
+     * <li>midGrayIn: sets the input middle gray</li>
+     * <li>midGrayOut: sets the output middle gray</li>
+     * <li>hdrMax: defines the maximum input value that will be mapped to
+     * output white</li>
+     * </ul>
+     */
+    public static class Generic extends ToneMapper {
+        /**
+         * Builds a new generic tone mapper parameterized to closely approximate
+         * the {@link ACESLegacy} tone mapper. The default values are:
+         *
+         * <ul>
+         * <li>contrast = 1.55f</li>
+         * <li>midGrayIn = 0.18f</li>
+         * <li>midGrayOut = 0.215f</li>
+         * <li>hdrMax = 10.0f</li>
+         * </ul>
+         */
+        public Generic() {
+            this(1.55f, 0.18f, 0.215f, 10.0f);
+        }
+
+        /**
+         * Builds a new generic tone mapper.
+         *
+         * @param contrast: controls the contrast of the curve, must be > 0.0, values
+         *                  in the range 0.5..2.0 are recommended.
+         * @param midGrayIn: sets the input middle gray, between 0.0 and 1.0.
+         * @param midGrayOut: sets the output middle gray, between 0.0 and 1.0.
+         * @param hdrMax: defines the maximum input value that will be mapped to
+         *                output white. Must be >= 1.0.
+         */
+        public Generic(
+                float contrast, float midGrayIn, float midGrayOut, float hdrMax) {
+            super(nCreateGenericToneMapper(contrast, midGrayIn, midGrayOut, hdrMax));
+        }
+
+        /** Returns the contrast of the curve as a strictly positive value. */
+        public float getContrast() {
+            return nGenericGetContrast(getNativeObject());
+        }
+
+        /** Sets the contrast of the curve, must be > 0.0, values in the range 0.5..2.0 are recommended. */
+        public void setContrast(float contrast) {
+            nGenericSetContrast(getNativeObject(), contrast);
+        }
+
+        /** Returns the middle gray point for input values as a value between 0.0 and 1.0. */
+        public float getMidGrayIn() {
+            return nGenericGetMidGrayIn(getNativeObject());
+        }
+
+        /** Sets the input middle gray, between 0.0 and 1.0. */
+        public void setMidGrayIn(float midGrayIn) {
+            nGenericSetMidGrayIn(getNativeObject(), midGrayIn);
+        }
+
+        /** Returns the middle gray point for output values as a value between 0.0 and 1.0. */
+        public float getMidGrayOut() {
+            return nGenericGetMidGrayOut(getNativeObject());
+        }
+
+        /** Sets the output middle gray, between 0.0 and 1.0. */
+        public void setMidGrayOut(float midGrayOut) {
+            nGenericSetMidGrayOut(getNativeObject(), midGrayOut);
+        }
+
+        /** Returns the maximum input value that will map to output white, as a value >= 1.0. */
+        public float getHdrMax() {
+            return nGenericGetHdrMax(getNativeObject());
+        }
+
+        /** Defines the maximum input value that will be mapped to output white. Must be >= 1.0. */
+        public void setHdrMax(float hdrMax) {
+            nGenericSetHdrMax(getNativeObject(), hdrMax);
+        }
+    }
+
+    private static native void nDestroyToneMapper(long nativeObject);
+
+    private static native long nCreateLinearToneMapper();
+    private static native long nCreateACESToneMapper();
+    private static native long nCreateACESLegacyToneMapper();
+    private static native long nCreateFilmicToneMapper();
+    private static native long nCreateGenericToneMapper(
+            float contrast, float midGrayIn, float midGrayOut, float hdrMax);
+
+    // Generic tone mappper
+    private static native float nGenericGetContrast(long nativeObject);
+    private static native float nGenericGetMidGrayIn(long nativeObject);
+    private static native float nGenericGetMidGrayOut(long nativeObject);
+    private static native float nGenericGetHdrMax(long nativeObject);
+
+    private static native void nGenericSetContrast(long nativeObject, float contrast);
+    private static native void nGenericSetMidGrayIn(long nativeObject, float midGrayIn);
+    private static native void nGenericSetMidGrayOut(long nativeObject, float midGrayOut);
+    private static native void nGenericSetHdrMax(long nativeObject, float hdrMax);
+}

android/filament-android/src/main/java/com/google/android/filament/TransformManager.java

@@ -83,6 +83,35 @@ import androidx.annotation.Size;
         return nGetInstance(mNativeObject, entity);
     }
 
+    /**
+     * Enables or disable the accurate translation mode. Disabled by default.
+     *
+     * When accurate translation mode is active, the translation component of all transforms is
+     * maintained at double precision. This is only useful if the mat4 version of setTransform()
+     * is used, as well as getTransformAccurate().
+     *
+     * @param enable true to enable the accurate translation mode, false to disable.
+     *
+     * @see #isAccurateTranslationsEnabled
+     * @see #create(int, int, double[])
+     * @see #setTransform(int, double[])
+     * @see #getTransform(int, double[])
+     * @see #getWorldTransform(int, double[])
+     */
+    public void setAccurateTranslationsEnabled(boolean enable) {
+        nSetAccurateTranslationsEnabled(mNativeObject, enable);
+    }
+
+    /**
+     * Returns whether the high precision translation mode is active.
+     *
+     * @return true if accurate translations mode is active, false otherwise
+     * @see #setAccurateTranslationsEnabled
+     */
+    public boolean isAccurateTranslationsEnabled() {
+        return nIsAccurateTranslationsEnabled(mNativeObject);
+    }
+
     /**
      * Creates a transform component and associates it with the given entity. The component is
      * initialized with the identity transform.
@@ -114,6 +143,23 @@ import androidx.annotation.Size;
         return nCreateArray(mNativeObject, entity, parent, localTransform);
     }
 
+    /**
+     * Creates a transform component with a parent and associates it with the given entity.
+     * If this component already exists on the given entity, it is first
+     * destroyed as if {@link #destroy} was called.
+     *
+     * @param entity         an {@link Entity} to associate a transform component to.
+     * @param parent         the  {@link EntityInstance} of the parent transform
+     * @param localTransform the transform, relative to the parent, to initialize the transform
+     *                       component with.
+     * @see #destroy
+     */
+    @EntityInstance
+    public int create(@Entity int entity, @EntityInstance int parent,
+            @Nullable @Size(min = 16) double[] localTransform) {
+        return nCreateArrayFp64(mNativeObject, entity, parent, localTransform);
+    }
+
     /**
      * Destroys this component from the given entity, children are orphaned.
      *
@@ -140,6 +186,19 @@ import androidx.annotation.Size;
         nSetParent(mNativeObject, i, newParent);
     }
 
+    /**
+     * Returns the actual parent entity of an {@link EntityInstance} originally defined
+     * by {@link #setParent(int, int)}.
+     *
+     * @param i the {@link EntityInstance} of the transform component to get the parent from.
+     * @return the parent {@link Entity}.
+     * @see #getInstance
+     */
+    @Entity
+    public int getParent(@EntityInstance int i) {
+        return nGetParent(mNativeObject, i);
+    }
+
     /**
      * Sets a local transform of a transform component.
      * <p>This operation can be slow if the hierarchy of transform is too deep, and this
@@ -157,6 +216,24 @@ import androidx.annotation.Size;
         nSetTransform(mNativeObject, i, localTransform);
     }
 
+    /**
+     * Sets a local transform of a transform component.
+     * <p>This operation can be slow if the hierarchy of transform is too deep, and this
+     * will be particularly bad when updating a lot of transforms. In that case,
+     * consider using {@link #openLocalTransformTransaction} / {@link #commitLocalTransformTransaction}.</p>
+     *
+     * @param i              the {@link EntityInstance} of the transform component to set the local
+     *                       transform to.
+     * @param localTransform the local transform (i.e. relative to the parent).
+     * @see #getTransform(int, double[])
+     * @see #getWorldTransform(int, double[])
+     */
+    public void setTransform(@EntityInstance int i,
+            @NonNull @Size(min = 16) double[] localTransform) {
+        Asserts.assertMat4In(localTransform);
+        nSetTransformFp64(mNativeObject, i, localTransform);
+    }
+
     /**
      * Returns the local transform of a transform component.
      *
@@ -177,6 +254,26 @@ import androidx.annotation.Size;
         return outLocalTransform;
     }
 
+    /**
+     * Returns the local transform of a transform component.
+     *
+     * @param i                 the {@link EntityInstance} of the transform component to query the
+     *                          local transform from.
+     * @param outLocalTransform a 16 <code>float</code> array to receive the result.
+     *                          If <code>null</code> is given,  a new suitable array is allocated.
+     * @return the local transform of the component (i.e. relative to the parent). This always
+     * returns the value set by setTransform().
+     * @see #setTransform
+     */
+    @NonNull
+    @Size(min = 16)
+    public double[] getTransform(@EntityInstance int i,
+            @Nullable @Size(min = 16) double[] outLocalTransform) {
+        outLocalTransform = Asserts.assertMat4(outLocalTransform);
+        nGetTransformFp64(mNativeObject, i, outLocalTransform);
+        return outLocalTransform;
+    }
+
     /**
      * Returns the world transform of a transform component.
      *
@@ -197,6 +294,26 @@ import androidx.annotation.Size;
         return outWorldTransform;
     }
 
+    /**
+     * Returns the world transform of a transform component.
+     *
+     * @param i                 the {@link EntityInstance} of the transform component to query the
+     *                          world transform from.
+     * @param outWorldTransform a 16 <code>float</code> array to receive the result.
+     *                          If <code>null</code> is given,  a new suitable array is allocated
+     * @return The world transform of the component (i.e. relative to the root). This is the
+     * composition of this component's local transform with its parent's world transform.
+     * @see #setTransform
+     */
+    @NonNull
+    @Size(min = 16)
+    public double[] getWorldTransform(@EntityInstance int i,
+            @Nullable @Size(min = 16) double[] outWorldTransform) {
+        outWorldTransform = Asserts.assertMat4(outWorldTransform);
+        nGetWorldTransformFp64(mNativeObject, i, outWorldTransform);
+        return outWorldTransform;
+    }
+
     /**
      * Opens a local transform transaction. During a transaction, {@link #getWorldTransform} can
      * return an invalid transform until {@link #commitLocalTransformTransaction} is called.
@@ -239,11 +356,18 @@ import androidx.annotation.Size;
     private static native int nGetInstance(long nativeTransformManager, int entity);
     private static native int nCreate(long nativeTransformManager, int entity);
     private static native int nCreateArray(long mNativeObject, int entity, int parent, float[] localTransform);
+    private static native int nCreateArrayFp64(long mNativeObject, int entity, int parent, double[] localTransform);
     private static native void nDestroy(long nativeTransformManager, int entity);
     private static native void nSetParent(long nativeTransformManager, int i, int newParent);
+    private static native int nGetParent(long nativeTransformManager, int i);
     private static native void nSetTransform(long nativeTransformManager, int i, float[] localTransform);
+    private static native void nSetTransformFp64(long nativeTransformManager, int i, double[] localTransform);
     private static native void nGetTransform(long nativeTransformManager, int i, float[] outLocalTransform);
+    private static native void nGetTransformFp64(long nativeTransformManager, int i, double[] outLocalTransform);
     private static native void nGetWorldTransform(long nativeTransformManager, int i, float[] outWorldTransform);
+    private static native void nGetWorldTransformFp64(long nativeTransformManager, int i, double[] outWorldTransform);
     private static native void nOpenLocalTransformTransaction(long nativeTransformManager);
     private static native void nCommitLocalTransformTransaction(long nativeTransformManager);
+    private static native void nSetAccurateTranslationsEnabled(long nativeTransformManager, boolean enable);
+    private static native boolean nIsAccurateTranslationsEnabled(long nativeTransformManager);
 }

android/filament-android/src/main/java/com/google/android/filament/VertexBuffer.java

@@ -66,14 +66,14 @@ public class VertexBuffer {
         BONE_INDICES, // indices of 4 bones (uvec4)
         BONE_WEIGHTS, // weights of the 4 bones (normalized float4)
         UNUSED,       // reserved for future use
-        CUSTOM0,      // custom or MORPH_POSITION_0
-        CUSTOM1,      // custom or MORPH_POSITION_1
-        CUSTOM2,      // custom or MORPH_POSITION_2
-        CUSTOM3,      // custom or MORPH_POSITION_3
-        CUSTOM4,      // custom or MORPH_TANGENTS_0
-        CUSTOM5,      // custom or MORPH_TANGENTS_1
-        CUSTOM6,      // custom or MORPH_TANGENTS_2
-        CUSTOM7       // custom or MORPH_TANGENTS_3
+        CUSTOM0,      // custom
+        CUSTOM1,      // custom
+        CUSTOM2,      // custom
+        CUSTOM3,      // custom
+        CUSTOM4,      // custom
+        CUSTOM5,      // custom
+        CUSTOM6,      // custom
+        CUSTOM7       // custom
     }
 
     public enum AttributeType {
@@ -104,48 +104,6 @@ public class VertexBuffer {
         HALF3,
         HALF4,
     }
-    /**
-     * Specifies the quaternion type for the {@link #populateTangentQuaternions} utility.
-     */
-    public enum QuatType {
-        /** 2 bytes per component as half-floats (8 bytes per quat) */
-        HALF4,
-
-        /** 2 bytes per component as normalized integers (8 bytes per quat) */
-        SHORT4,
-
-        /** 4 bytes per component as floats (16 bytes per quat) */
-        FLOAT4,
-    }
-
-    /**
-     * Specifies the parameters for the {@link #populateTangentQuaternions} utility.
-     */
-    public static class QuatTangentContext {
-        /** desired quaternion type (required) */
-        public QuatType quatType;
-
-        /** number of quaternions (required) */
-        public int quatCount;
-
-        /** pre-allocated output buffer (required) */
-        public Buffer outBuffer;
-
-        /** desired stride in bytes (optional) */
-        public int outStride;
-
-        /** source normals (required) */
-        public Buffer normals;
-
-        /** normals stride in bytes (optional) */
-        public int normalsStride;
-
-        /** source tangents (optional) */
-        public Buffer tangents;
-
-        /** tangents stride in bytes (optional) */
-        public int tangentsStride;
-    }
 
     public static class Builder {
         @SuppressWarnings({"FieldCanBeLocal", "UnusedDeclaration"}) // Keep to finalize native resources
@@ -170,6 +128,21 @@ public class VertexBuffer {
             return this;
         }
 
+        /**
+         * Allows buffers to be swapped out and shared using BufferObject.
+         *
+         * If buffer objects mode is enabled, clients must call setBufferObjectAt rather than
+         * setBufferAt. This allows sharing of data between VertexBuffer objects, but it may
+         * slightly increase the memory footprint of Filament's internal bookkeeping.
+         *
+         * @param enabled If true, enables buffer object mode.  False by default.
+         */
+        @NonNull
+        public Builder enableBufferObjects(boolean enabled) {
+            nBuilderEnableBufferObjects(mNativeBuilder, enabled);
+            return this;
+        }
+
         /**
          * Defines how many buffers will be created in this vertex buffer set. These buffers are
          * later referenced by index from 0 to <code>bufferCount</code> - 1.
@@ -397,36 +370,21 @@ public class VertexBuffer {
             throw new BufferOverflowException();
         }
     }
+
     /**
-     * Convenience function that consumes normal vectors (and, optionally, tangent vectors) and
-     * produces quaternions that can be passed into a TANGENTS buffer.
+     * Swaps in the given buffer object.
      *
-     * <p>
-     * The given output buffer must be preallocated with at least quatCount * outStride bytes.
-     * <p>
+     * To use this, you must first call enableBufferObjects() on the Builder.
      *
-     * <p>
-     * Normals are required but tangents are optional, in which case this function tries to generate
-     * reasonable tangents. The given normals should be unit length.
-     * </p>
-     *
-     * <p>
-     * If supplied, the tangent vectors should be unit length and should be orthogonal to the
-     * normals. The w component of the tangent is a sign (-1 or +1) indicating handedness of the
-     * basis.
-     * </p>
-     *
-     * @deprecated Instead please use SurfaceOrientation since it has additional capabilities and a
-     * builder-style API.
-     *
-     * @param context an initialized QuatTangentContext object
+     * @param engine Reference to the filament::Engine to associate this VertexBuffer with.
+     * @param bufferIndex Index of the buffer to initialize. Must be between 0
+     *                    and Builder::bufferCount() - 1.
+     * @param bufferObject The handle to the GPU data that will be used in this buffer slot.
      */
-    public static void populateTangentQuaternions(@NonNull QuatTangentContext context) {
-        nPopulateTangentQuaternions(context.quatType.ordinal(), context.quatCount,
-                context.outBuffer, context.outBuffer.remaining(), context.outStride,
-                context.normals, context.normals.remaining(), context.normalsStride,
-                context.tangents, context.tangents != null ? context.tangents.remaining() : 0,
-                context.tangentsStride);
+    public void setBufferObjectAt(@NonNull Engine engine, int bufferIndex,
+            @NonNull BufferObject bufferObject) {
+        nSetBufferObjectAt(getNativeObject(), engine.getNativeObject(), bufferIndex,
+                bufferObject.getNativeObject());
     }
 
     public long getNativeObject() {
@@ -443,6 +401,7 @@ public class VertexBuffer {
     private static native long nCreateBuilder();
     private static native void nDestroyBuilder(long nativeBuilder);
     private static native void nBuilderVertexCount(long nativeBuilder, int vertexCount);
+    private static native void nBuilderEnableBufferObjects(long nativeBuilder, boolean enabled);
     private static native void nBuilderBufferCount(long nativeBuilder, int bufferCount);
     private static native void nBuilderAttribute(long nativeBuilder, int attribute,
             int bufferIndex, int attributeType, int byteOffset, int byteStride);
@@ -455,7 +414,6 @@ public class VertexBuffer {
             int bufferIndex, Buffer buffer, int remaining, int destOffsetInBytes, int count,
             Object handler, Runnable callback);
 
-    private static native void nPopulateTangentQuaternions(int quatType, int quatCount,
-            Buffer outBuffer, int outRemaining, int outStride, Buffer normals, int normalsRemaining,
-            int normalsStride, Buffer tangents, int tangentsRemaining, int tangentsStride);
+    private static native void nSetBufferObjectAt(long nativeVertexBuffer, long nativeEngine,
+            int bufferIndex, long nativeBufferObject);
 }

android/filament-android/src/main/java/com/google/android/filament/View.java

@@ -59,6 +59,10 @@ import static com.google.android.filament.Colors.LinearColor;
  * @see RenderTarget
  */
 public class View {
+    private static final AntiAliasing[] sAntiAliasingValues = AntiAliasing.values();
+    private static final Dithering[] sDitheringValues = Dithering.values();
+    private static final AmbientOcclusion[] sAmbientOcclusionValues = AmbientOcclusion.values();
+
     private long mNativeObject;
     private String mName;
     private Scene mScene;
@@ -75,6 +79,9 @@ public class View {
     private VignetteOptions mVignetteOptions;
     private ColorGrading mColorGrading;
     private TemporalAntiAliasingOptions mTemporalAntiAliasingOptions;
+    private MultiSampleAntiAliasingOptions mMultiSampleAntiAliasingOptions;
+    private VsmShadowOptions mVsmShadowOptions;
+    private SoftShadowOptions mSoftShadowOptions;
 
     /**
      * Generic quality level.
@@ -130,8 +137,20 @@ public class View {
         public float maxScale = 1.0f;
 
         /**
-         * Upscaling quality. LOW: 1 bilinear tap, MEDIUM: 4 bilinear taps, HIGH: 9 bilinear taps.
-         * If minScale needs to be very low, it might help to use MEDIUM or HIGH here.
+         * Sharpness when QualityLevel.MEDIUM or higher is used [0, 1].
+         * 0 is disabled, 1 is the sharpest setting.
+         * The default is set to 0.9
+         */
+        public float sharpness = 0.9f;
+
+        /**
+         * Upscaling quality
+         * LOW: bilinear filtered blit. Fastest, poor quality
+         * MEDIUM: AMD FidelityFX FSR1 w/ mobile optimizations no RCAS sharpening pass
+         * HIGH:   AMD FidelityFX FSR1 w/ mobile optimizations + RCAS
+         * ULTRA:  AMD FidelityFX FSR1
+         *      FSR1 require a well anti-aliased (MSAA or TAA), noise free scene.
+         *
          * The default upscaling quality is set to LOW.
          */
         @NonNull
@@ -168,6 +187,16 @@ public class View {
          */
         public float intensity = 1.0f;
 
+        /**
+         * Depth distance that constitute an edge for filtering. Must be positive.
+         * Default is 5cm.
+         * This must be adjusted with the scene's scale and/or units.
+         * A value too low will result in high frequency noise, while a value too high will
+         * result in the loss of geometry edges. For AO, it is generally better to be too
+         * blurry than not enough.
+         */
+        public float bilateralThreshold = 0.05f;
+
         /**
          * The quality setting controls the number of samples used for evaluating Ambient
          * occlusion. The default is QualityLevel.LOW which is sufficient for most mobile
@@ -176,6 +205,14 @@ public class View {
         @NonNull
         public QualityLevel quality = QualityLevel.LOW;
 
+        /**
+         * The lowPassFilter setting controls the quality of the low pass filter applied to
+         * AO estimation. The default is QualityLevel.MEDIUM which is sufficient for most mobile
+         * applications. QualityLevel.LOW disables the filter entirely.
+         */
+        @NonNull
+        public QualityLevel lowPassFilter = QualityLevel.MEDIUM;
+
         /**
          * The upsampling setting controls the quality of the ambient occlusion buffer upsampling.
          * The default is QualityLevel.LOW and uses bilinear filtering, a value of
@@ -188,11 +225,104 @@ public class View {
          * enable or disable screen space ambient occlusion
          */
         public boolean enabled = false;
+
+        /**
+         * enables bent normals computation from AO, and specular AO
+         */
+        public boolean bentNormals = false;
+
+        /**
+         * Minimal angle to consider in radian. This is used to reduce the creases that can
+         * appear due to insufficiently tessellated geometry.
+         * For e.g. a good values to try could be around 0.2.
+         */
+        public float minHorizonAngleRad = 0.0f;
+
+
+       /**
+        * Full cone angle in radian, between 0 and pi/2. This affects the softness of the shadows,
+        * as well as how far they are cast. A smaller angle yields to sharper and shorter shadows.
+        * The default angle is about 60 degrees.
+        */
+       public float ssctLightConeRad = 1.0f;
+
+       /**
+        * Distance from where tracing starts.
+        * This affects how far shadows are cast.
+        */
+       public float ssctStartTraceDistance = 0.01f;
+
+       /**
+        * Maximum contact distance with the cone. Intersections between the traced cone and
+        * geometry samller than this distance are ignored.
+        */
+       public float ssctContactDistanceMax = 1.0f;
+
+       /**
+        * Intensity of the shadows.
+        */
+       public float ssctIntensity = 0.8f;
+
+       /**
+        * Light direction.
+        */
+       @NonNull @Size(min = 3)
+       public float[] ssctLightDirection = { 0, -1, 0 };
+
+       /**
+        * Depth bias in world units (mitigate self shadowing)
+        */
+       public float ssctDepthBias = 0.01f;
+
+       /**
+        * Depth slope bias (mitigate self shadowing)
+        */
+       public float ssctDepthSlopeBias = 0.01f;
+
+       /**
+        * Tracing sample count, between 1 and 255. This affects the quality as well as the
+        * distance of the shadows.
+        */
+       public int ssctSampleCount = 4;
+
+       /**
+        * Numbers of rays to trace, between 1 and 255. This affects the noise of the shadows.
+        * Performance degrades quickly with this value.
+        */
+       public int ssctRayCount = 1;
+
+       /**
+        * Enables or disables SSCT.
+        */
+       public boolean ssctEnabled = false;
     }
 
+    /**
+     * Options for Multi-sample Anti-aliasing (MSAA)
+     * @see View#setMultiSampleAntiAliasingOptions
+     */
+    public static class MultiSampleAntiAliasingOptions {
+        /** enables or disables temporal anti-aliasing */
+        public boolean enabled = false;
+
+        /**
+         * number of samples to use for multi-sampled anti-aliasing.\n
+         *      0: treated as 1
+         *      1: no anti-aliasing
+         *      n: sample count. Effective sample could be different depending on the
+         *         GPU capabilities.
+         */
+        public int sampleCount = 4;
+
+        /**
+         * custom resolve improves quality for HDR scenes, but may impact performance.
+         */
+        public boolean customResolve = false;
+    };
+
     /**
      * Options for Temporal Anti-aliasing (TAA)
-     * @see View#setTemporalAntiAliasingOptions()
+     * @see View#setTemporalAntiAliasingOptions
      */
     public static class TemporalAntiAliasingOptions {
         /** reconstruction filter width typically between 0 (sharper, aliased) and 1 (smoother) */
@@ -210,11 +340,11 @@ public class View {
      *
      * enabled:     Enable or disable the bloom post-processing effect. Disabled by default.
      * levels:      Number of successive blurs to achieve the blur effect, the minimum is 3 and the
-     *              maximum is 12. This value together with resolution influences the spread of the
+     *              maximum is 11. This value together with resolution influences the spread of the
      *              blur effect. This value can be silently reduced to accommodate the original
      *              image size.
-     * resolution:  Resolution of bloom's minor axis. The minimum value is 2^levels and the
-     *              the maximum is lower of the original resolution and 4096. This parameter is
+     * resolution:  Resolution of bloom's vertical axis. The minimum value is 2^levels and the
+     *              the maximum is lower of the original resolution and 2048. This parameter is
      *              silently clamped to the minimum and maximum.
      *              It is highly recommended that this value be smaller than the target resolution
      *              after dynamic resolution is applied (horizontally and vertically).
@@ -255,7 +385,7 @@ public class View {
         public float strength = 0.10f;
 
         /**
-         * Resolution of minor axis (2^levels to 4096)
+         * Resolution of minor axis (2^levels to 2048)
          */
         public int resolution = 360;
 
@@ -265,7 +395,7 @@ public class View {
         public float anamorphism = 1.0f;
 
         /**
-         * Number of blur levels (3 to 12)
+         * Number of blur levels (3 to 11)
          */
         public int levels = 6;
 
@@ -289,6 +419,52 @@ public class View {
          * minimum value is 10.0.
          */
         public float highlight = 1000.0f;
+
+
+        /**
+         * enable screen-space lens flare
+         */
+        public boolean lensFlare = false;
+
+        /**
+         * enable starburst effect on lens flare
+         */
+        public boolean starburst = true;
+
+        /**
+         * amount of chromatic aberration
+         */
+        public float chromaticAberration = 0.005f;
+
+        /**
+         * number of flare "ghosts"
+         */
+        public int ghostCount = 4;
+
+        /**
+         * spacing of the ghost in screen units [0, 1[
+         */
+        public float ghostSpacing = 0.6f;
+
+        /**
+         * hdr threshold for the ghosts
+         */
+        public float ghostThreshold = 10.0f;
+
+        /**
+         * thickness of halo in vertical screen units, 0 to disable
+         */
+        public float haloThickness = 0.1f;
+
+        /**
+         * radius of halo in vertical screen units [0, 0.5]
+         */
+        public float haloRadius = 0.4f;
+
+        /**
+         * hdr threshold for the halo
+         */
+        public float haloThreshold = 10.0f;
     }
 
     /**
@@ -335,9 +511,9 @@ public class View {
         public float inScatteringStart = 0.0f;
 
         /**
-         * size of in-scattering (>=0 to activate). Good values are >> 1 (e.g. ~10 - 100)
+         * size of in-scattering (>0 to activate). Good values are >> 1 (e.g. ~10 - 100)
          */
-        public float inScatteringSize = 0.0f;
+        public float inScatteringSize = -1.0f;
 
         /**
          * fog color will be modulated by the IBL color in the view direction
@@ -357,17 +533,81 @@ public class View {
      */
     public static class DepthOfFieldOptions {
 
-        /** focus distance in world units */
-        public float focusDistance = 10.0f;
+        public enum Filter {
+            NONE,
+            MEDIAN
+        }
 
-        /** scale factor controlling the amount of blur (values other than 1.0 are not physically correct)*/
-        public float blurScale = 1.0f;
+        /**
+         * circle of confusion scale factor (amount of blur)
+         *
+         * <p>cocScale can be used to set the depth of field blur independently from the camera
+         * aperture, e.g. for artistic reasons. This can be achieved by setting:</p>
+         * <code>
+         *      cocScale = cameraAperture / desiredDoFAperture
+         * </code>
+         *
+         */
+        public float cocScale = 1.0f;
 
         /** maximum aperture diameter in meters (zero to disable bokeh rotation) */
         public float maxApertureDiameter = 0.01f;
 
         /** enable or disable Depth of field effect */
         public boolean enabled = false;
+
+        /** filter to use for filling gaps in the kernel */
+        @NonNull
+        public Filter filter = Filter.MEDIAN;
+
+        /** perform DoF processing at native resolution */
+        public boolean nativeResolution = false;
+
+        /**
+         * <p>Number of of rings used by the foreground kernel. The number of rings affects quality
+         * and performance. The actual number of sample per pixel is defined
+         * as (ringCount * 2 - 1)^2. Here are a few commonly used values:</p>
+         *       3 rings :   25 ( 5x 5 grid)
+         *       4 rings :   49 ( 7x 7 grid)
+         *       5 rings :   81 ( 9x 9 grid)
+         *      17 rings : 1089 (33x33 grid)
+         *
+         * <p>With a maximum circle-of-confusion of 32, it is never necessary to use more than 17 rings.</p>
+         *
+         * <p>Usually all three settings below are set to the same value, however, it is often
+         * acceptable to use a lower ring count for the "fast tiles", which improves performance.
+         * Fast tiles are regions of the screen where every pixels have a similar
+         * circle-of-confusion radius.</p>
+         *
+         * <p>A value of 0 means default, which is 5 on desktop and 3 on mobile.</p>
+         */
+        public int foregroundRingCount = 0;
+
+        /**
+         * Number of of rings used by the background kernel. The number of rings affects quality
+         * and performance.
+         * @see #foregroundRingCount
+         */
+        public int backgroundRingCount = 0;
+
+        /**
+         * Number of of rings used by the fast gather kernel. The number of rings affects quality
+         * and performance.
+         * @see #foregroundRingCount
+         */
+        public int fastGatherRingCount = 0;
+
+        /**
+         * maximum circle-of-confusion in pixels for the foreground, must be in [0, 32] range.
+         * A value of 0 means default, which is 32 on desktop and 24 on mobile.
+         */
+        public int maxForegroundCOC = 0;
+
+        /**
+         * maximum circle-of-confusion in pixels for the background, must be in [0, 32] range.
+         * A value of 0 means default, which is 32 on desktop and 24 on mobile.
+         */
+        public int maxBackgroundCOC = 0;
     };
 
     /**
@@ -483,6 +723,92 @@ public class View {
         TEMPORAL
     }
 
+    /**
+     * List of available shadow mapping techniques.
+     *
+     * @see #setShadowType
+     */
+    public enum ShadowType {
+        /**
+         * Percentage-closer filtered shadows (default).
+         */
+        PCF,
+
+        /**
+         * Variance shadows.
+         */
+        VSM,
+
+        /**
+         * Percentage-closer filtered shadows, with contact hardening simulation.
+         */
+        DPCF,
+
+        /**
+         * Percentage-closer soft shadows
+         */
+        PCSS
+    }
+
+    /**
+     * View-level options for VSM shadowing.
+     *
+     * <strong>Warning: This API is still experimental and subject to change.</strong>
+     *
+     * @see View#setVsmShadowOptions
+     */
+    public static class VsmShadowOptions {
+        /**
+         * Sets the number of anisotropic samples to use when sampling a VSM shadow map. If greater
+         * than 0, mipmaps will automatically be generated each frame for all lights.
+         * This implies mipmapping below.
+         *
+         * <p>
+         * The number of anisotropic samples = 2 ^ vsmAnisotropy.
+         * </p>
+         *
+         */
+        public int anisotropy = 0;
+
+        /**
+         * Whether to generate mipmaps for all VSM shadow maps.
+         */
+        public boolean mipmapping = false;
+
+        /**
+         * VSM minimum variance scale, must be positive.
+         */
+        public float minVarianceScale = 1.0f;
+
+        /**
+         * VSM light bleeding reduction amount, between 0 and 1.
+         */
+        public float lightBleedReduction = 0.2f;
+    }
+
+    /**
+     * View-level options for DPCF and PCSS Shadowing.
+     *
+     * <strong>Warning: This API is still experimental and subject to change.</strong>
+     *
+     * @see View#setSoftShadowOptions
+     */
+    public static class SoftShadowOptions {
+        /**
+         * Globally scales the penumbra of all DPCF and PCSS shadows
+         * Acceptable values are greater than 0
+         */
+        public float penumbraScale = 1.0f;
+
+        /**
+         * Globally scales the computed penumbra ratio of all DPCF and PCSS shadows.
+         * This effectively controls the strength of contact hardening effect and is useful for
+         * artistic purposes. Higher values make the shadows become softer faster.
+         * Acceptable values are equal to or greater than 1.
+         */
+        public float penumbraRatioScale = 1.0f;
+    }
+
     /**
      * Used to select buffers.
      */
@@ -707,8 +1033,31 @@ public class View {
      * @see RenderableManager.Builder#receiveShadows
      * @see RenderableManager.Builder#castShadows
      */
-    public void setShadowsEnabled(boolean enabled) {
-        nSetShadowsEnabled(getNativeObject(), enabled);
+    public void setShadowingEnabled(boolean enabled) {
+        nSetShadowingEnabled(getNativeObject(), enabled);
+    }
+
+    /**
+     * @return whether shadowing is enabled
+     */
+    boolean isShadowingEnabled() {
+        return nIsShadowingEnabled(getNativeObject());
+    }
+
+    /**
+     * Enables or disables screen space refraction. Enabled by default.
+     *
+     * @param enabled true enables screen space refraction, false disables it.
+     */
+    public void setScreenSpaceRefractionEnabled(boolean enabled) {
+        nSetScreenSpaceRefractionEnabled(getNativeObject(), enabled);
+    }
+
+    /**
+     * @return whether screen space refraction is enabled
+     */
+    boolean isScreenSpaceRefractionEnabled() {
+        return nIsScreenSpaceRefractionEnabled(getNativeObject());
     }
 
     /**
@@ -753,7 +1102,10 @@ public class View {
      * </p>
      *
      * @param count number of samples to use for multi-sampled anti-aliasing.
+     *
+     * @deprecated use setMultiSampleAntiAliasingOptions instead
      */
+    @Deprecated
     public void setSampleCount(int count) {
         nSetSampleCount(getNativeObject(), count);
     }
@@ -766,7 +1118,10 @@ public class View {
      * </p>
      *
      * @return value set by {@link #setSampleCount}
+     *
+     * @deprecated use getMultiSampleAntiAliasingOptions instead
      */
+    @Deprecated
     public int getSampleCount() {
         return nGetSampleCount(getNativeObject());
     }
@@ -792,7 +1147,31 @@ public class View {
      */
     @NonNull
     public AntiAliasing getAntiAliasing() {
-        return AntiAliasing.values()[nGetAntiAliasing(getNativeObject())];
+        return sAntiAliasingValues[nGetAntiAliasing(getNativeObject())];
+    }
+
+    /**
+     * Enables or disable multi-sample anti-aliasing (MSAA). Disabled by default.
+     *
+     * @param options multi-sample anti-aliasing options
+     */
+    public void setMultiSampleAntiAliasingOptions(@NonNull MultiSampleAntiAliasingOptions options) {
+        mMultiSampleAntiAliasingOptions = options;
+        nSetMultiSampleAntiAliasingOptions(getNativeObject(),
+                options.enabled, options.sampleCount, options.customResolve);
+    }
+
+    /**
+     * Returns multi-sample anti-aliasing options.
+     *
+     * @return multi-sample anti-aliasing options
+     */
+    @NonNull
+    public MultiSampleAntiAliasingOptions getMultiSampleAntiAliasingOptions() {
+        if (mMultiSampleAntiAliasingOptions == null) {
+            mMultiSampleAntiAliasingOptions = new MultiSampleAntiAliasingOptions();
+        }
+        return mMultiSampleAntiAliasingOptions;
     }
 
     /**
@@ -881,7 +1260,7 @@ public class View {
      */
     @NonNull
     public Dithering getDithering() {
-        return Dithering.values()[nGetDithering(getNativeObject())];
+        return sDitheringValues[nGetDithering(getNativeObject())];
     }
 
     /**
@@ -906,6 +1285,7 @@ public class View {
                 options.homogeneousScaling,
                 options.minScale,
                 options.maxScale,
+                options.sharpness,
                 options.quality.ordinal());
     }
 
@@ -957,21 +1337,26 @@ public class View {
      *
      * <p>Post-processing includes:</p>
      * <ul>
-     * <li>Tone-mapping & gamma encoding</li>
+     * <li>Depth-of-field</li>
+     * <li>Bloom</li>
+     * <li>Vignetting</li>
+     * <li>Temporal Anti-aliasing (TAA)</li>
+     * <li>Color grading & gamma encoding</li>
      * <li>Dithering</li>
-     * <li>MSAA</li>
      * <li>FXAA</li>
      * <li>Dynamic scaling</li>
      * </ul>
      *
      * <p>
-     * Disabling post-processing forgoes color correctness as well as anti-aliasing and
-     * should only be used experimentally (e.g., for UI overlays).
+     * Disabling post-processing forgoes color correctness as well as some anti-aliasing techniques
+     * and should only be used for debugging, UI overlays or when using custom render targets
+     * (see RenderTarget).
      * </p>
      *
      * @param enabled true enables post processing, false disables it
      *
-     * @see #setToneMapping
+     * @see #setBloomOptions
+     * @see #setColorGrading
      * @see #setAntiAliasing
      * @see #setDithering
      * @see #setSampleCount
@@ -1031,6 +1416,88 @@ public class View {
         nSetDynamicLightingOptions(getNativeObject(), zLightNear, zLightFar);
     }
 
+    /**
+     * Sets the shadow mapping technique this View uses.
+     *
+     * The ShadowType affects all the shadows seen within the View.
+     *
+     * <p>
+     * {@link ShadowType#VSM} imposes a restriction on marking renderables as only shadow receivers
+     * (but not casters). To ensure correct shadowing with VSM, all shadow participant renderables
+     * should be marked as both receivers and casters. Objects that are guaranteed to not cast
+     * shadows on themselves or other objects (such as flat ground planes) can be set to not cast
+     * shadows, which might improve shadow quality.
+     * </p>
+     *
+     * <strong>Warning: This API is still experimental and subject to change.</strong>
+     */
+    public void setShadowType(ShadowType type) {
+        nSetShadowType(getNativeObject(), type.ordinal());
+    }
+
+    /**
+     * Sets VSM shadowing options that apply across the entire View.
+     *
+     * Additional light-specific VSM options can be set with
+     * {@link LightManager.Builder#shadowOptions}.
+     *
+     * Only applicable when shadow type is set to ShadowType::VSM.
+     *
+     * <strong>Warning: This API is still experimental and subject to change.</strong>
+     *
+     * @param options Options for shadowing.
+     * @see #setShadowType
+     */
+    public void setVsmShadowOptions(@NonNull VsmShadowOptions options) {
+        mVsmShadowOptions = options;
+        nSetVsmShadowOptions(getNativeObject(), options.anisotropy, options.mipmapping,
+                options.minVarianceScale, options.lightBleedReduction);
+    }
+
+    /**
+     * Gets the VSM shadowing options.
+     * @see #setVsmShadowOptions
+     * @return VSM shadow options currently set.
+     */
+    @NonNull
+    public VsmShadowOptions getVsmShadowOptions() {
+        if (mVsmShadowOptions == null) {
+            mVsmShadowOptions = new VsmShadowOptions();
+        }
+        return mVsmShadowOptions;
+    }
+
+    /**
+     * Sets soft shadowing options that apply across the entire View.
+     *
+     * Additional light-specific VSM options can be set with
+     * {@link LightManager.Builder#shadowOptions}.
+     *
+     * Only applicable when shadow type is set to ShadowType.DPCF.
+     *
+     * <strong>Warning: This API is still experimental and subject to change.</strong>
+     *
+     * @param options Options for shadowing.
+     * @see #setShadowType
+     */
+    public void setSoftShadowOptions(@NonNull SoftShadowOptions options) {
+        mSoftShadowOptions = options;
+        nSetSoftShadowOptions(getNativeObject(), options.penumbraScale, options.penumbraRatioScale);
+    }
+
+    /**
+     * Gets soft shadowing options associated with this View.
+     * @see #setSoftShadowOptions
+     * @return soft shadow options currently set.
+     */
+    @NonNull
+    public SoftShadowOptions getSoftShadowOptions() {
+        if (mSoftShadowOptions == null) {
+            mSoftShadowOptions = new SoftShadowOptions();
+        }
+        return mSoftShadowOptions;
+    }
+
     /**
      * Activates or deactivates ambient occlusion.
      * @see #setAmbientOcclusionOptions
@@ -1049,7 +1516,7 @@ public class View {
     @Deprecated
     @NonNull
     public AmbientOcclusion getAmbientOcclusion() {
-        return AmbientOcclusion.values()[nGetAmbientOcclusion(getNativeObject())];
+        return sAmbientOcclusionValues[nGetAmbientOcclusion(getNativeObject())];
     }
 
     /**
@@ -1060,8 +1527,14 @@ public class View {
     public void setAmbientOcclusionOptions(@NonNull AmbientOcclusionOptions options) {
         mAmbientOcclusionOptions = options;
         nSetAmbientOcclusionOptions(getNativeObject(), options.radius, options.bias, options.power,
-                options.resolution, options.intensity, options.quality.ordinal(), options.upsampling.ordinal(),
-                options.enabled);
+                options.resolution, options.intensity, options.bilateralThreshold,
+                options.quality.ordinal(), options.lowPassFilter.ordinal(), options.upsampling.ordinal(),
+                options.enabled, options.bentNormals, options.minHorizonAngleRad);
+        nSetSSCTOptions(getNativeObject(), options.ssctLightConeRad, options.ssctStartTraceDistance,
+                options.ssctContactDistanceMax,  options.ssctIntensity,
+                options.ssctLightDirection[0], options.ssctLightDirection[1], options.ssctLightDirection[2],
+                options.ssctDepthBias, options.ssctDepthSlopeBias, options.ssctSampleCount,
+                options.ssctRayCount, options.ssctEnabled);
     }
 
     /**
@@ -1088,7 +1561,10 @@ public class View {
         nSetBloomOptions(getNativeObject(), options.dirt != null ? options.dirt.getNativeObject() : 0,
                 options.dirtStrength, options.strength, options.resolution,
                 options.anamorphism, options.levels, options.blendingMode.ordinal(),
-                options.threshold, options.enabled, options.highlight);
+                options.threshold, options.enabled, options.highlight,
+                options.lensFlare, options.starburst, options.chromaticAberration,
+                options.ghostCount, options.ghostSpacing, options.ghostThreshold,
+                options.haloThickness, options.haloRadius, options.haloThreshold);
     }
 
     /**
@@ -1173,7 +1649,10 @@ public class View {
      */
     public void setDepthOfFieldOptions(@NonNull DepthOfFieldOptions options) {
         mDepthOfFieldOptions = options;
-        nSetDepthOfFieldOptions(getNativeObject(), options.focusDistance, options.blurScale, options.maxApertureDiameter, options.enabled);
+        nSetDepthOfFieldOptions(getNativeObject(), options.cocScale,
+                options.maxApertureDiameter, options.enabled, options.filter.ordinal(),
+                options.nativeResolution, options.foregroundRingCount, options.backgroundRingCount,
+                options.fastGatherRingCount, options.maxForegroundCOC, options.maxBackgroundCOC);
     }
 
     /**
@@ -1190,6 +1669,71 @@ public class View {
         return mDepthOfFieldOptions;
     }
 
+    /**
+     * A class containing the result of a picking query
+     */
+    public static class PickingQueryResult {
+        /** The entity of the renderable at the picking query location */
+        @Entity public int renderable;
+        /** The value of the depth buffer at the picking query location */
+        public float depth;
+        /** The fragment coordinate in GL convention at the picking query location */
+        @NonNull public float[] fragCoords = new float[3];
+    };
+
+    /**
+     * An interface to implement a custom class to receive results of picking queries.
+     */
+    public interface OnPickCallback {
+        /**
+         * onPick() is called by the specified Handler in {@link View#pick} when the picking query
+         * result is available.
+         * @param result An instance of {@link PickingQueryResult}.
+         */
+        void onPick(@NonNull PickingQueryResult result);
+    }
+
+    /**
+     * Creates a picking query. Multiple queries can be created (e.g.: multi-touch).
+     * Picking queries are all executed when {@link Renderer#render} is called on this View.
+     * The provided callback is guaranteed to be called at some point in the future.
+     *
+     * Typically it takes a couple frames to receive the result of a picking query.
+     *
+     * @param x        Horizontal coordinate to query in the viewport with origin on the left.
+     * @param y        Vertical coordinate to query on the viewport with origin at the bottom.
+     * @param handler  An {@link java.util.concurrent.Executor Executor}.
+     *                 On Android this can also be a {@link android.os.Handler Handler}.
+     * @param callback User callback executed by <code>handler</code> when the picking query
+     *                 result is available.
+     */
+    public void pick(int x, int y,
+            @Nullable Object handler, @Nullable OnPickCallback callback) {
+        InternalOnPickCallback internalCallback = new InternalOnPickCallback(callback);
+        nPick(getNativeObject(), x, y, handler, internalCallback);
+    }
+
+    private static class InternalOnPickCallback implements Runnable {
+        public InternalOnPickCallback(OnPickCallback mUserCallback) {
+            this.mUserCallback = mUserCallback;
+        }
+        @Override
+        public void run() {
+            mPickingQueryResult.renderable = mRenderable;
+            mPickingQueryResult.depth = mDepth;
+            mPickingQueryResult.fragCoords[0] = mFragCoordsX;
+            mPickingQueryResult.fragCoords[1] = mFragCoordsY;
+            mPickingQueryResult.fragCoords[2] = mFragCoordsZ;
+            mUserCallback.onPick(mPickingQueryResult);
+        }
+        private final OnPickCallback mUserCallback;
+        private final PickingQueryResult mPickingQueryResult = new PickingQueryResult();
+        @Entity int mRenderable;
+        float mDepth;
+        float mFragCoordsX;
+        float mFragCoordsY;
+        float mFragCoordsZ;
+    }
 
     public long getNativeObject() {
         if (mNativeObject == 0) {
@@ -1207,7 +1751,7 @@ public class View {
     private static native void nSetCamera(long nativeView, long nativeCamera);
     private static native void nSetViewport(long nativeView, int left, int bottom, int width, int height);
     private static native void nSetVisibleLayers(long nativeView, int select, int value);
-    private static native void nSetShadowsEnabled(long nativeView, boolean enabled);
+    private static native void nSetShadowingEnabled(long nativeView, boolean enabled);
     private static native void nSetRenderTarget(long nativeView, long nativeRenderTarget);
     private static native void nSetSampleCount(long nativeView, int count);
     private static native int nGetSampleCount(long nativeView);
@@ -1215,9 +1759,12 @@ public class View {
     private static native int nGetAntiAliasing(long nativeView);
     private static native void nSetDithering(long nativeView, int dithering);
     private static native int nGetDithering(long nativeView);
-    private static native void nSetDynamicResolutionOptions(long nativeView, boolean enabled, boolean homogeneousScaling, float minScale, float maxScale, int quality);
+    private static native void nSetDynamicResolutionOptions(long nativeView, boolean enabled, boolean homogeneousScaling, float minScale, float maxScale, float sharpness, int quality);
     private static native void nSetRenderQuality(long nativeView, int hdrColorBufferQuality);
     private static native void nSetDynamicLightingOptions(long nativeView, float zLightNear, float zLightFar);
+    private static native void nSetShadowType(long nativeView, int type);
+    private static native void nSetVsmShadowOptions(long nativeView, int anisotropy, boolean mipmapping, float minVarianceScale, float lightBleedReduction);
+    private static native void nSetSoftShadowOptions(long nativeView, float penumbraScale, float penumbraRatioScale);
     private static native void nSetColorGrading(long nativeView, long nativeColorGrading);
     private static native void nSetPostProcessingEnabled(long nativeView, boolean enabled);
     private static native boolean nIsPostProcessingEnabled(long nativeView);
@@ -1225,11 +1772,19 @@ public class View {
     private static native boolean nIsFrontFaceWindingInverted(long nativeView);
     private static native void nSetAmbientOcclusion(long nativeView, int ordinal);
     private static native int nGetAmbientOcclusion(long nativeView);
-    private static native void nSetAmbientOcclusionOptions(long nativeView, float radius, float bias, float power, float resolution, float intensity, int quality, int upsampling, boolean enabled);
-    private static native void nSetBloomOptions(long nativeView, long dirtNativeObject, float dirtStrength, float strength, int resolution, float anamorphism, int levels, int blendMode, boolean threshold, boolean enabled, float highlight);
+    private static native void nSetAmbientOcclusionOptions(long nativeView, float radius, float bias, float power, float resolution, float intensity, float bilateralThreshold, int quality, int lowPassFilter, int upsampling, boolean enabled, boolean bentNormals, float minHorizonAngleRad);
+    private static native void nSetSSCTOptions(long nativeView, float ssctLightConeRad, float ssctStartTraceDistance, float ssctContactDistanceMax, float ssctIntensity, float v, float v1, float v2, float ssctDepthBias, float ssctDepthSlopeBias, int ssctSampleCount, int ssctRayCount, boolean ssctEnabled);
+    private static native void nSetBloomOptions(long nativeView, long dirtNativeObject, float dirtStrength, float strength, int resolution, float anamorphism, int levels, int blendMode, boolean threshold, boolean enabled, float highlight,
+            boolean lensFlare, boolean starburst, float chromaticAberration, int ghostCount, float ghostSpacing, float ghostThreshold, float haloThickness, float haloRadius, float haloThreshold);
     private static native void nSetFogOptions(long nativeView, float distance, float maximumOpacity, float height, float heightFalloff, float v, float v1, float v2, float density, float inScatteringStart, float inScatteringSize, boolean fogColorFromIbl, boolean enabled);
     private static native void nSetBlendMode(long nativeView, int blendMode);
-    private static native void nSetDepthOfFieldOptions(long nativeView, float focusDistance, float blurScale, float maxApertureDiameter, boolean enabled);
+    private static native void nSetDepthOfFieldOptions(long nativeView, float cocScale, float maxApertureDiameter, boolean enabled, int filter,
+            boolean nativeResolution, int foregroundRingCount, int backgroundRingCount, int fastGatherRingCount, int maxForegroundCOC, int maxBackgroundCOC);
     private static native void nSetVignetteOptions(long nativeView, float midPoint, float roundness, float feather, float r, float g, float b, float a, boolean enabled);
     private static native void nSetTemporalAntiAliasingOptions(long nativeView, float feedback, float filterWidth, boolean enabled);
+    private static native void nSetMultiSampleAntiAliasingOptions(long nativeView, boolean enabled, int sampleCount, boolean customResolve);
+    private static native boolean nIsShadowingEnabled(long nativeView);
+    private static native void nSetScreenSpaceRefractionEnabled(long nativeView, boolean enabled);
+    private static native boolean nIsScreenSpaceRefractionEnabled(long nativeView);
+    private static native void nPick(long nativeView, int x, int y, Object handler, InternalOnPickCallback internalCallback);
 }

android/filament-android/src/main/java/com/google/android/filament/android/TextureHelper.java

@@ -23,8 +23,6 @@ import androidx.annotation.NonNull;
 import com.google.android.filament.Engine;
 import com.google.android.filament.Texture;
 
-import java.lang.reflect.Method;
-
 public final class TextureHelper {
     // Keep in sync with Texture.cpp
     private static final int BITMAP_CONFIG_ALPHA_8    = 0;

android/filament-android/src/main/java/com/google/android/filament/android/UiHelper.java

@@ -30,8 +30,8 @@ import android.view.TextureView;
 import com.google.android.filament.SwapChain;
 
 /**
- * UiHelper is a simple class that can manage either a SurfaceView or a TextureView so it can
- * be used to render into with Filament.
+ * UiHelper is a simple class that can manage either a SurfaceView, TextureView, or a SurfaceHolder
+ * so it can be used to render into with Filament.
  *
  * Here is a simple example with a SurfaceView. The code would be exactly the same with a
  * TextureView:
@@ -191,6 +191,23 @@ public class UiHelper {
         }
     }
 
+    private static class SurfaceHolderHandler implements RenderSurface {
+        private SurfaceHolder mSurfaceHolder;
+
+        SurfaceHolderHandler(SurfaceHolder surface) {
+            mSurfaceHolder = surface;
+        }
+
+        @Override
+        public void resize(int width, int height) {
+            mSurfaceHolder.setFixedSize(width, height);
+        }
+
+        @Override
+        public void detach() {
+        }
+    }
+
     private class TextureViewHandler implements RenderSurface {
         private TextureView mTextureView;
         private Surface mSurface;
@@ -258,8 +275,8 @@ public class UiHelper {
     }
 
     /**
-     * Free resources associated to the native window specified in {@link #attachTo(SurfaceView)}
-     * or {@link #attachTo(TextureView)}.
+     * Free resources associated to the native window specified in {@link #attachTo(SurfaceView)},
+     * {@link #attachTo(TextureView)}, or {@link #attachTo(SurfaceHolder)}.
      */
     public void detach() {
         destroySwapChain();
@@ -315,8 +332,8 @@ public class UiHelper {
      * Controls whether the render target (SurfaceView or TextureView) is opaque or not.
      * The render target is considered opaque by default.
      *
-     * Must be called before calling {@link #attachTo(SurfaceView)}
-     * or {@link #attachTo(TextureView)}.
+     * Must be called before calling {@link #attachTo(SurfaceView)}, {@link #attachTo(TextureView)},
+     * or {@link #attachTo(SurfaceHolder)}.
      *
      * @param opaque Indicates whether the render target should be opaque. True by default.
      */
@@ -341,6 +358,8 @@ public class UiHelper {
      * Must be called before calling {@link #attachTo(SurfaceView)}
      * or {@link #attachTo(TextureView)}.
      *
+     * Has no effect when using {@link #attachTo(SurfaceHolder)}.
+     *
      * @param overlay Indicates whether the render target should be rendered below the activity's
      *                surface when transparent.
      */
@@ -403,7 +422,9 @@ public class UiHelper {
 
             SurfaceHolder holder = view.getHolder();
             holder.addCallback(callback);
-            holder.setFixedSize(mDesiredWidth, mDesiredHeight);
+            if (mDesiredWidth > 0 && mDesiredHeight > 0) {
+                holder.setFixedSize(mDesiredWidth, mDesiredHeight);
+            }
 
             // in case the SurfaceView's surface already existed
             final Surface surface = holder.getSurface();
@@ -483,6 +504,55 @@ public class UiHelper {
         }
     }
 
+    /**
+     * Associate UiHelper with a SurfaceHolder.
+     *
+     * As soon as a Surface is created, we'll create the
+     * EGL resources needed, and call user callbacks if needed.
+     */
+    public void attachTo(@NonNull SurfaceHolder holder) {
+        if (attach(holder)) {
+            int format = isOpaque() ? PixelFormat.OPAQUE : PixelFormat.TRANSLUCENT;
+            holder.setFormat(format);
+
+            mRenderSurface = new SurfaceHolderHandler(holder);
+
+            final SurfaceHolder.Callback callback = new SurfaceHolder.Callback() {
+                @Override
+                public void surfaceCreated(SurfaceHolder surfaceHolder) {
+                    if (LOGGING) Log.d(LOG_TAG, "surfaceCreated()");
+                    createSwapChain(holder.getSurface());
+                }
+
+                @Override
+                public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
+                    // Note: this is always called at least once after surfaceCreated()
+                    if (LOGGING) Log.d(LOG_TAG, "surfaceChanged(" + width + ", " + height + ")");
+                    mRenderCallback.onResized(width, height);
+                }
+
+                @Override
+                public void surfaceDestroyed(SurfaceHolder surfaceHolder) {
+                    if (LOGGING) Log.d(LOG_TAG, "surfaceDestroyed()");
+                    destroySwapChain();
+                }
+            };
+
+            holder.addCallback(callback);
+            if (mDesiredWidth > 0 && mDesiredHeight > 0) {
+                holder.setFixedSize(mDesiredWidth, mDesiredHeight);
+            }
+
+            // in case the SurfaceHolder's surface already existed
+            final Surface surface = holder.getSurface();
+            if (surface != null && surface.isValid()) {
+                callback.surfaceCreated(holder);
+                callback.surfaceChanged(holder, format,
+                        holder.getSurfaceFrame().width(), holder.getSurfaceFrame().height());
+            }
+        }
+    }
+
     private boolean attach(@NonNull Object nativeWindow) {
         if (mNativeWindow != null) {
             // we are already attached to a native window

android/filament-utils-android/CMakeLists.txt

@@ -1,6 +1,8 @@
-cmake_minimum_required(VERSION 3.6)
+cmake_minimum_required(VERSION 3.19)
+project(filament-utils-android)
 
 set(FILAMENT_DIR ${FILAMENT_DIST_DIR})
+set(IMAGEIO_DIR ../../libs/imageio)
 
 add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/../gltfio-android ${CMAKE_CURRENT_BINARY_DIR}/gltfio-android)
 
@@ -12,27 +14,55 @@ add_library(image STATIC IMPORTED)
 set_target_properties(image PROPERTIES IMPORTED_LOCATION
         ${FILAMENT_DIR}/lib/${ANDROID_ABI}/libimage.a)
 
-include_directories(${FILAMENT_DIR}/include
-        ..
-        ../../libs/utils/include)
+add_library(viewer STATIC IMPORTED)
+set_target_properties(viewer PROPERTIES IMPORTED_LOCATION
+        ${FILAMENT_DIR}/lib/${ANDROID_ABI}/libviewer.a)
+
+add_library(civetweb STATIC IMPORTED)
+set_target_properties(civetweb PROPERTIES IMPORTED_LOCATION
+        ${FILAMENT_DIR}/lib/${ANDROID_ABI}/libcivetweb.a)
+
+add_library(iblprefilter STATIC IMPORTED)
+set_target_properties(iblprefilter PROPERTIES IMPORTED_LOCATION
+        ${FILAMENT_DIR}/lib/${ANDROID_ABI}/libfilament-iblprefilter.a)
 
 set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} -Wl,--version-script=${CMAKE_CURRENT_SOURCE_DIR}/libfilament-utils-jni.map")
 
 add_library(filament-utils-jni SHARED
+        src/main/cpp/AutomationEngine.cpp
         src/main/cpp/Bookmark.cpp
+        src/main/cpp/HDRLoader.cpp
+        src/main/cpp/IBLPrefilterContext.cpp
         src/main/cpp/Utils.cpp
         src/main/cpp/Manipulator.cpp
+        src/main/cpp/RemoteServer.cpp
+
+        ${IMAGEIO_DIR}/include/imageio/ImageDecoder.h
+        ${IMAGEIO_DIR}/include/imageio/HDRDecoder.h
+        ${IMAGEIO_DIR}/src/HDRDecoder.cpp
 
         ../common/CallbackUtils.cpp
         ../common/NioUtils.cpp
 )
 
+target_compile_definitions(filament-utils-jni PUBLIC IMAGEIO_LITE=1)
+
+target_include_directories(filament-utils-jni PRIVATE
+        ${FILAMENT_DIR}/include
+        ..
+        ../../filament/backend/include
+        ${IMAGEIO_DIR}/include
+        ../../libs/utils/include)
+
 set_target_properties(filament-utils-jni PROPERTIES LINK_DEPENDS
         ${CMAKE_CURRENT_SOURCE_DIR}/libfilament-utils-jni.symbols)
 
 # The ordering in the following list is important because CMake does not have dependency information.
 target_link_libraries(filament-utils-jni
         gltfio-jni
+        civetweb
         camutils
+        iblprefilter
         image
+        viewer
 )

android/filament-utils-android/build.gradle

@@ -1,5 +1,4 @@
 apply plugin: 'kotlin-android'
-apply plugin: 'kotlin-android-extensions'
 
 android {
     flavorDimensions "functionality"
@@ -10,6 +9,13 @@ android {
 
         lite {
             dimension "functionality"
+            externalNativeBuild {
+                cmake {
+                    // hack: this is needed because filament-utils-android/CMakeLists.txt builds
+                    // gltfio from source, which needs this defined
+                    arguments.add("-DGLTFIO_LITE=ON")
+                }
+            }
         }
     }
 
@@ -44,13 +50,14 @@ configurations.all { config ->
 dependencies {
     implementation deps.kotlin
     implementation deps.androidx.annotations
-    implementation project(':filament-android')
 
-    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.3'
-    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.3'
+    implementation deps.coroutines.core
+    implementation deps.coroutines.android
 
-    fullImplementation module("com.google.android.filament:gltfio-android:${VERSION_NAME}")
-    liteImplementation module("com.google.android.filament:gltfio-android-lite:${VERSION_NAME}")
+    api project(':filament-android')
+
+    fullApi module("com.google.android.filament:gltfio-android:${VERSION_NAME}")
+    liteApi module("com.google.android.filament:gltfio-android-lite:${VERSION_NAME}")
 }
 
 apply from: rootProject.file('gradle/gradle-mvn-push.gradle')

android/filament-utils-android/src/main/cpp/AutomationEngine.cpp

@@ -0,0 +1,213 @@
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <jni.h>
+
+#include <viewer/AutomationEngine.h>
+
+using namespace filament;
+using namespace filament::viewer;
+using namespace utils;
+
+extern "C" JNIEXPORT jlong JNICALL
+Java_com_google_android_filament_utils_AutomationEngine_nCreateAutomationEngine(JNIEnv* env, jclass,
+        jstring spec_) {
+    const char* spec = env->GetStringUTFChars(spec_, 0);
+    jlong result = (jlong) AutomationEngine::createFromJSON(spec, strlen(spec));
+    env->ReleaseStringUTFChars(spec_, spec);
+    return result;
+}
+
+extern "C" JNIEXPORT jlong JNICALL
+Java_com_google_android_filament_utils_AutomationEngine_nCreateDefaultAutomationEngine(JNIEnv* env,
+        jclass klass) {
+    return (jlong) AutomationEngine::createDefault();
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_utils_AutomationEngine_nSetOptions(JNIEnv* env, jclass klass,
+        jlong nativeAutomation, jfloat sleepDuration, jint minFrameCount, jboolean verbose) {
+    AutomationEngine* automation = (AutomationEngine*) nativeAutomation;
+    AutomationEngine::Options options = {
+        .sleepDuration = sleepDuration,
+        .minFrameCount = minFrameCount,
+        .verbose = (bool) verbose,
+
+        // Since they write to the filesystem, we do not currently support exporting screenshots
+        // and JSON files on Android.
+        .exportScreenshots = false,
+        .exportSettings = false,
+    };
+    automation->setOptions(options);
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_utils_AutomationEngine_nStartRunning(JNIEnv* env, jclass klass,
+        jlong nativeAutomation) {
+    AutomationEngine* automation = (AutomationEngine*) nativeAutomation;
+    automation->startRunning();
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_utils_AutomationEngine_nStartBatchMode(JNIEnv* env, jclass klass,
+        jlong nativeAutomation) {
+    AutomationEngine* automation = (AutomationEngine*) nativeAutomation;
+    automation->startBatchMode();
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_utils_AutomationEngine_nTick(JNIEnv* env, jclass klass,
+        jlong nativeAutomation, jlong view, jlongArray materials, jlong renderer, jfloat deltaTime) {
+    using MaterialPointer = MaterialInstance*;
+    jsize materialCount = 0;
+    jlong* longMaterials = nullptr;
+    MaterialPointer* ptrMaterials = nullptr;
+    if (materials) {
+        materialCount = env->GetArrayLength(materials);
+        ptrMaterials = new MaterialPointer[materialCount];
+        longMaterials = env->GetLongArrayElements(materials, nullptr);
+        for (jsize i = 0; i < materialCount; i++) {
+            ptrMaterials[i] = (MaterialPointer) longMaterials[i];
+        }
+    }
+    AutomationEngine* automation = (AutomationEngine*) nativeAutomation;
+    AutomationEngine::ViewerContent content = {
+        .view = (View*) view,
+        .renderer = (Renderer*) renderer,
+        .materials = ptrMaterials,
+        .materialCount = (size_t) materialCount,
+    };
+    automation->tick(content, deltaTime);
+    if (longMaterials) {
+        env->ReleaseLongArrayElements(materials, longMaterials, 0);
+        delete[] ptrMaterials;
+    }
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_utils_AutomationEngine_nApplySettings(JNIEnv* env, jclass klass,
+        jlong nativeAutomation, jstring json, jlong view, jlongArray materials, jlong nativeIbl,
+        jint sunlightEntity, jintArray assetLights, jlong nativeLm, jlong scene, jlong renderer) {
+    using MaterialPointer = MaterialInstance*;
+
+    jsize materialCount = 0;
+    jlong* longMaterials = nullptr;
+    MaterialPointer* ptrMaterials = nullptr;
+    if (materials) {
+        materialCount = env->GetArrayLength(materials);
+        ptrMaterials = new MaterialPointer[materialCount];
+        longMaterials = env->GetLongArrayElements(materials, nullptr);
+        for (jsize i = 0; i < materialCount; i++) {
+            ptrMaterials[i] = (MaterialPointer) longMaterials[i];
+        }
+    }
+
+    jsize lightCount = 0;
+    jint* intLights = nullptr;
+    if (assetLights) {
+        lightCount = env->GetArrayLength(assetLights);
+        intLights = env->GetIntArrayElements(assetLights, nullptr);
+    }
+
+    static_assert(sizeof(jint) == sizeof(Entity));
+
+    AutomationEngine* automation = (AutomationEngine*) nativeAutomation;
+    const char* nativeJson = env->GetStringUTFChars(json, 0);
+    size_t jsonLength = env->GetStringUTFLength(json);
+
+    AutomationEngine::ViewerContent content = {
+        .view = (View*) view,
+        .renderer = (Renderer*) renderer,
+        .materials = ptrMaterials,
+        .materialCount = (size_t) materialCount,
+        .lightManager = (LightManager*) nativeLm,
+        .scene = (Scene*) scene,
+        .indirectLight = (IndirectLight*) nativeIbl,
+        .sunlight = (Entity&) sunlightEntity,
+        .assetLights = (Entity*) intLights,
+        .assetLightCount = (size_t) lightCount,
+    };
+
+    automation->applySettings(nativeJson, jsonLength, content);
+    env->ReleaseStringUTFChars(json, nativeJson);
+    if (longMaterials) {
+        env->ReleaseLongArrayElements(materials, longMaterials, 0);
+        delete[] ptrMaterials;
+    }
+    if (intLights) {
+        env->ReleaseIntArrayElements(assetLights, intLights, 0);
+    }
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_utils_AutomationEngine_nGetViewerOptions(JNIEnv* env, jclass,
+        jlong nativeObject, jobject result) {
+    AutomationEngine* automation = (AutomationEngine*) nativeObject;
+    auto options = automation->getViewerOptions();
+
+    const jclass klass = env->GetObjectClass(result);
+
+    const jfieldID cameraAperture = env->GetFieldID(klass, "cameraAperture", "F");
+    const jfieldID cameraSpeed = env->GetFieldID(klass, "cameraSpeed", "F");
+    const jfieldID cameraISO = env->GetFieldID(klass, "cameraISO", "F");
+    const jfieldID groundShadowStrength = env->GetFieldID(klass, "groundShadowStrength", "F");
+    const jfieldID groundPlaneEnabled = env->GetFieldID(klass, "groundPlaneEnabled", "Z");
+    const jfieldID skyboxEnabled = env->GetFieldID(klass, "skyboxEnabled", "Z");
+    const jfieldID cameraFocalLength = env->GetFieldID(klass, "cameraFocalLength", "F");
+    const jfieldID cameraFocusDistance = env->GetFieldID(klass, "cameraFocusDistance", "F");
+    const jfieldID autoScaleEnabled = env->GetFieldID(klass, "autoScaleEnabled", "Z");
+
+    env->SetFloatField(result, cameraAperture, options.cameraAperture);
+    env->SetFloatField(result, cameraSpeed, options.cameraSpeed);
+    env->SetFloatField(result, cameraISO, options.cameraISO);
+    env->SetFloatField(result, groundShadowStrength, options.groundShadowStrength);
+    env->SetBooleanField(result, groundPlaneEnabled, options.groundPlaneEnabled);
+    env->SetBooleanField(result, skyboxEnabled, options.skyboxEnabled);
+    env->SetFloatField(result, cameraFocalLength, options.cameraFocalLength);
+    env->SetFloatField(result, cameraFocusDistance, options.cameraFocusDistance);
+    env->SetBooleanField(result, autoScaleEnabled, options.autoScaleEnabled);
+}
+
+extern "C" JNIEXPORT jlong JNICALL
+Java_com_google_android_filament_utils_AutomationEngine_nGetColorGrading(JNIEnv*, jclass,
+        jlong nativeObject, jlong nativeEngine) {
+    AutomationEngine* automation = (AutomationEngine*) nativeObject;
+    return (jlong) automation->getColorGrading((Engine*) nativeEngine);
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_utils_AutomationEngine_nSignalBatchMode(JNIEnv*, jclass, jlong native) {
+    AutomationEngine* automation = (AutomationEngine*) native;
+    automation->signalBatchMode();
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_utils_AutomationEngine_nStopRunning(JNIEnv*, jclass, jlong native) {
+    AutomationEngine* automation = (AutomationEngine*) native;
+    automation->stopRunning();
+}
+
+extern "C" JNIEXPORT jboolean JNICALL
+Java_com_google_android_filament_utils_AutomationEngine_nShouldClose(JNIEnv*, jclass, jlong native) {
+    AutomationEngine* automation = (AutomationEngine*) native;
+    return automation->shouldClose();
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_utils_AutomationEngine_nDestroy(JNIEnv*, jclass, jlong native) {
+    AutomationEngine* automation = (AutomationEngine*) native;
+    delete automation;
+}

android/filament-utils-android/src/main/cpp/HDRLoader.cpp

@@ -0,0 +1,91 @@
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <jni.h>
+
+#include <filament/Engine.h>
+#include <filament/Texture.h>
+
+#include <imageio/HDRDecoder.h>
+
+#include <utils/Log.h>
+
+#include <sstream>
+
+#include "common/NioUtils.h"
+
+using namespace filament;
+using namespace image;
+using namespace utils;
+
+using PixelBufferDescriptor = Texture::PixelBufferDescriptor;
+
+jlong nCreateHDRTexture(JNIEnv* env, jclass,
+        jlong nativeEngine, jobject javaBuffer, jint remaining, jint internalFormat) {
+
+    Engine* engine = (Engine*) nativeEngine;
+    AutoBuffer buffer(env, javaBuffer, remaining);
+    Texture::InternalFormat textureFormat = (Texture::InternalFormat) internalFormat;
+
+    auto dataPtr = (char const*) buffer.getData();
+    const size_t byteCount = buffer.getSize();
+
+    // This creates a copy but it's the easest way to create a memory stream.
+    std::string ins(dataPtr, byteCount);
+    std::istringstream in(ins);
+
+    LinearImage* image = new LinearImage(ImageDecoder::decode(in, "memory.hdr"));
+
+    // This can happen if a decoding error occurs.
+    if (image->getChannels() != 3) {
+        delete image;
+        return 0;
+    }
+
+    Texture* texture = Texture::Builder()
+        .width(image->getWidth())
+        .height(image->getHeight())
+        .levels(0xff)
+        .sampler(Texture::Sampler::SAMPLER_2D)
+        .format(textureFormat)
+        .build(*engine);
+
+    if (texture == nullptr) {
+        slog.e << "Unable to create Filament Texture from HDR image." << io::endl;
+        delete image;
+        return 0;
+    }
+
+    PixelBufferDescriptor::Callback freeCallback = [](void* buf, size_t, void* userdata) {
+        delete (LinearImage*) userdata;
+    };
+
+    PixelBufferDescriptor pbd(
+        (void const* ) image->getPixelRef(),
+        image->getWidth() * image->getHeight() * 3 * sizeof(float),
+        PixelBufferDescriptor::PixelDataFormat::RGB,
+        PixelBufferDescriptor::PixelDataType::FLOAT,
+        freeCallback,
+        image);
+
+    // Note that the setImage call could fail (e.g. due to an invalid combination of internal format
+    // and PixelDataFormat) but there is no way of detecting such a failure.
+    texture->setImage(*engine, 0, std::move(pbd));
+
+    texture->generateMipmaps(*engine);
+
+    return (jlong) texture;
+}

android/filament-utils-android/src/main/cpp/IBLPrefilterContext.cpp

@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <jni.h>
+
+#include <filament-iblprefilter/IBLPrefilterContext.h>
+
+#include <filament/Engine.h>
+#include <filament/Texture.h>
+
+using namespace filament;
+
+extern "C" JNIEXPORT jlong JNICALL
+Java_com_google_android_filament_utils_IBLPrefilterContext_nCreate(JNIEnv* env, jclass,
+        jlong nativeEngine) {
+    Engine* engine = (Engine*) nativeEngine;
+    return (jlong) new IBLPrefilterContext(*engine);
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_utils_IBLPrefilterContext_nDestroy(JNIEnv*, jclass, jlong native) {
+    IBLPrefilterContext* context = (IBLPrefilterContext*) native;
+    delete context;
+}
+
+extern "C" JNIEXPORT long JNICALL
+Java_com_google_android_filament_utils_IBLPrefilterContext_nCreateEquirectHelper(JNIEnv* env, jclass, jlong nativeContext) {
+    IBLPrefilterContext* context = (IBLPrefilterContext*) nativeContext;
+    return (long) new IBLPrefilterContext::EquirectangularToCubemap(*context);
+}
+
+extern "C" JNIEXPORT long JNICALL
+Java_com_google_android_filament_utils_IBLPrefilterContext_nEquirectHelperRun(JNIEnv* env, jclass, jlong nativeHelper, long nativeEquirect) {
+    auto helper = (IBLPrefilterContext::EquirectangularToCubemap*) nativeHelper;
+    auto texture = (filament::Texture*) nativeEquirect;
+    auto result = (*helper)(texture);
+    return (long) result;
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_utils_IBLPrefilterContext_nDestroyEquirectHelper(JNIEnv* env, jclass, jlong nativeObject) {
+    delete (IBLPrefilterContext::EquirectangularToCubemap*) nativeObject;
+}
+
+extern "C" JNIEXPORT long JNICALL
+Java_com_google_android_filament_utils_IBLPrefilterContext_nCreateSpecularFilter(JNIEnv* env, jclass, jlong nativeContext) {
+    IBLPrefilterContext* context = (IBLPrefilterContext*) nativeContext;
+    return (long) new IBLPrefilterContext::SpecularFilter(*context);
+}
+
+extern "C" JNIEXPORT long JNICALL
+Java_com_google_android_filament_utils_IBLPrefilterContext_nSpecularFilterRun(JNIEnv* env, jclass, jlong nativeHelper, long nativeSkybox) {
+    auto helper = (IBLPrefilterContext::SpecularFilter*) nativeHelper;
+    auto texture = (filament::Texture*) nativeSkybox;
+    auto result = (*helper)(texture);
+    return (long) result;
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_utils_IBLPrefilterContext_nDestroySpecularFilter(JNIEnv* env, jclass, jlong nativeObject) {
+    delete (IBLPrefilterContext::SpecularFilter*) nativeObject;
+}

android/filament-utils-android/src/main/cpp/RemoteServer.cpp

@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <jni.h>
+
+#include <viewer/RemoteServer.h>
+
+using namespace filament::viewer;
+
+extern "C" JNIEXPORT jlong JNICALL
+Java_com_google_android_filament_utils_RemoteServer_nCreate(JNIEnv* env, jclass, jint port) {
+    RemoteServer* server = new RemoteServer(port);
+    if (!server->isValid()) {
+        delete server;
+        return 0;
+    }
+    return (jlong) server;
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_utils_RemoteServer_nDestroy(JNIEnv*, jclass, jlong native) {
+    RemoteServer* server = (RemoteServer*) native;
+    delete server;
+}
+
+extern "C" JNIEXPORT jstring JNICALL
+Java_com_google_android_filament_utils_RemoteServer_nPeekIncomingLabel(JNIEnv* env, jclass, jlong native) {
+    RemoteServer* server = (RemoteServer*) native;
+    char const* label = server->peekIncomingLabel();
+    return label ? env->NewStringUTF(label) : nullptr;
+}
+
+extern "C" JNIEXPORT jstring JNICALL
+Java_com_google_android_filament_utils_RemoteServer_nPeekReceivedLabel(JNIEnv* env, jclass, jlong native) {
+    RemoteServer* server = (RemoteServer*) native;
+    ReceivedMessage const* msg = server->peekReceivedMessage();
+    return msg ? env->NewStringUTF(msg->label) : nullptr;
+}
+
+extern "C" JNIEXPORT jint JNICALL
+Java_com_google_android_filament_utils_RemoteServer_nPeekReceivedBufferLength(JNIEnv* env, jclass, jlong native) {
+    RemoteServer* server = (RemoteServer*) native;
+    ReceivedMessage const* msg = server->peekReceivedMessage();
+    return msg ? msg->bufferByteCount : 0;
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_utils_RemoteServer_nAcquireReceivedMessage(JNIEnv* env, jclass, jlong native, jobject buffer, jint length) {
+    RemoteServer* server = (RemoteServer*) native;
+    ReceivedMessage const* msg = server->acquireReceivedMessage();
+    if (msg == nullptr) {
+        return;
+    }
+
+    void* address = env->GetDirectBufferAddress(buffer);
+    if (address == nullptr) {
+        // This should never happen because the Java layer does allocateDirect.
+        return;
+    }
+
+    memcpy(address, msg->buffer, length);
+    server->releaseReceivedMessage(msg);
+}
+

android/filament-utils-android/src/main/cpp/Utils.cpp

@@ -28,7 +28,10 @@ using namespace filament;
 using namespace filament::math;
 using namespace image;
 
-static jlong nCreateTexture(JNIEnv* env, jclass,
+jlong nCreateHDRTexture(JNIEnv* env, jclass,
+        jlong nativeEngine, jobject javaBuffer, jint remaining, jint internalFormat);
+
+static jlong nCreateKTXTexture(JNIEnv* env, jclass,
         jlong nativeEngine, jobject javaBuffer, jint remaining, jboolean srgb) {
     Engine* engine = (Engine*) nativeEngine;
     AutoBuffer buffer(env, javaBuffer, remaining);
@@ -73,6 +76,19 @@ static jlong nCreateSkybox(JNIEnv* env, jclass,
     return (jlong) Skybox::Builder().environment(cubemap).showSun(true).build(*engine);
 }
 
+static jboolean nGetSphericalHarmonics(JNIEnv* env, jclass, jobject javaBuffer, jint remaining,
+        jfloatArray outSphericalHarmonics_) {
+    AutoBuffer buffer(env, javaBuffer, remaining);
+    KtxBundle bundle((const uint8_t*) buffer.getData(), buffer.getSize());
+
+    jfloat* outSphericalHarmonics = env->GetFloatArrayElements(outSphericalHarmonics_, nullptr);
+    const auto success = bundle.getSphericalHarmonics(
+        reinterpret_cast<filament::math::float3*>(outSphericalHarmonics)
+    );
+    env->ReleaseFloatArrayElements(outSphericalHarmonics_, outSphericalHarmonics, JNI_ABORT);
+
+    return success ? JNI_TRUE : JNI_FALSE;
+}
 
 JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void*) {
     JNIEnv* env;
@@ -80,15 +96,27 @@ JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void*) {
         return -1;
     }
 
-    jclass c = env->FindClass("com/google/android/filament/utils/KtxLoader");
-    if (c == nullptr) return JNI_ERR;
+    int rc;
 
-    static const JNINativeMethod methods[] = {
-        {"nCreateTexture", "(JLjava/nio/Buffer;IZ)J", reinterpret_cast<void*>(nCreateTexture)},
-        {"nCreateIndirectLight", "(JLjava/nio/Buffer;IZ)J", reinterpret_cast<void*>(nCreateIndirectLight)},
-        {"nCreateSkybox", "(JLjava/nio/Buffer;IZ)J", reinterpret_cast<void*>(nCreateSkybox)},
+    // KTXLoader
+    jclass ktxloaderClass = env->FindClass("com/google/android/filament/utils/KTXLoader");
+    if (ktxloaderClass == nullptr) return JNI_ERR;
+    static const JNINativeMethod ktxMethods[] = {
+        {(char*)"nCreateKTXTexture", (char*)"(JLjava/nio/Buffer;IZ)J", reinterpret_cast<void*>(nCreateKTXTexture)},
+        {(char*)"nCreateIndirectLight", (char*)"(JLjava/nio/Buffer;IZ)J", reinterpret_cast<void*>(nCreateIndirectLight)},
+        {(char*)"nCreateSkybox", (char*)"(JLjava/nio/Buffer;IZ)J", reinterpret_cast<void*>(nCreateSkybox)},
+        {(char*)"nGetSphericalHarmonics", (char*)"(Ljava/nio/Buffer;I[F)Z", reinterpret_cast<void*>(nGetSphericalHarmonics)},
     };
-    int rc = env->RegisterNatives(c, methods, sizeof(methods) / sizeof(JNINativeMethod));
+    rc = env->RegisterNatives(ktxloaderClass, ktxMethods, sizeof(ktxMethods) / sizeof(JNINativeMethod));
+    if (rc != JNI_OK) return rc;
+
+    // HDRLoader
+    jclass hdrloaderClass = env->FindClass("com/google/android/filament/utils/HDRLoader");
+    if (hdrloaderClass == nullptr) return JNI_ERR;
+    static const JNINativeMethod hdrMethods[] = {
+        {(char*)"nCreateHDRTexture", (char*)"(JLjava/nio/Buffer;II)J", reinterpret_cast<void*>(nCreateHDRTexture)},
+    };
+    rc = env->RegisterNatives(hdrloaderClass, hdrMethods, sizeof(hdrMethods) / sizeof(JNINativeMethod));
     if (rc != JNI_OK) return rc;
 
     return JNI_VERSION_1_6;

android/filament-utils-android/src/main/java/com/google/android/filament/utils/AutomationEngine.java

@@ -0,0 +1,280 @@
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.android.filament.utils;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.google.android.filament.ColorGrading;
+import com.google.android.filament.Engine;
+import com.google.android.filament.Entity;
+import com.google.android.filament.IndirectLight;
+import com.google.android.filament.LightManager;
+import com.google.android.filament.Scene;
+import com.google.android.filament.View;
+import com.google.android.filament.MaterialInstance;
+import com.google.android.filament.Renderer;
+
+/**
+ * The AutomationEngine makes it easy to push a bag of settings values to Filament.
+ * It can also be used to iterate through settings permutations for testing purposes.
+ *
+ * When creating an automation engine for testing purposes, clients give it a JSON string that
+ * tells it how to generate permutations of settings. Automation is always in one of two states:
+ * running or idle. The running state can be entered immediately (startRunning) or by requesting
+ * batch mode (startBatchMode).
+ *
+ * When executing a test, clients should call tick() after each frame is rendered, which provides an
+ * opportunity to push settings to Filament, increment the current test index (if enough time has
+ * elapsed), and request an asychronous screenshot.
+ *
+ * The time to sleep between tests is configurable and can be set to zero. Automation also waits a
+ * specified minimum number of frames between tests.
+ *
+ * Batch mode is meant for non-interactive applications. In batch mode, automation defers applying
+ * the first test case until the client unblocks it via signalBatchMode(). This is useful when
+ * waiting for a large model file to become fully loaded. Batch mode also offers a query
+ * (shouldClose) that is triggered after the last test has been invoked.
+ */
+public class AutomationEngine {
+    private final long mNativeObject;
+    private ColorGrading mColorGrading;
+
+    /**
+     * Allows users to toggle screenshots, change the sleep duration between tests, etc.
+     */
+    public static class Options {
+        /**
+         * Minimum time that automation waits between applying a settings object and advancing
+         * to the next test case. Specified in seconds.
+         */
+        public float sleepDuration = 0.2f;
+
+        /**
+         * Similar to sleepDuration, but expressed as a frame count. Both the minimum sleep time
+         * and the minimum frame count must be elapsed before automation advances to the next test.
+         */
+        public int minFrameCount = 2;
+
+        /**
+         * If true, test progress is dumped to the utils Log (info priority).
+         */
+        public boolean verbose = true;
+    }
+
+    /**
+     * Collection of Filament objects that can be modified by the automation engine.
+     */
+    public static class ViewerContent {
+        public View view;
+        public Renderer renderer;
+        public MaterialInstance[] materials;
+        public LightManager lightManager;
+        public Scene scene;
+        public IndirectLight indirectLight;
+        public @Entity int sunlight;
+        public @Entity int[] assetLights;
+    }
+
+    /**
+     * Allows remote control for the viewer.
+     */
+    public static class ViewerOptions {
+        public float cameraAperture = 16.0f;
+        public float cameraSpeed = 125.0f;
+        public float cameraISO = 100.0f;
+        public float groundShadowStrength = 0.75f;
+        public boolean groundPlaneEnabled = false;
+        public boolean skyboxEnabled = true;
+        public float cameraFocalLength = 28.0f;
+        public float cameraFocusDistance = 0.0f;
+        public boolean autoScaleEnabled = true;
+    }
+
+    /**
+     * Creates an automation engine from a JSON specification.
+     *
+     * An example of a JSON spec can be found by searching the repo for DEFAULT_AUTOMATION.
+     * This is documented using a JSON schema (look for viewer/schemas/automation.json).
+     *
+     * @param jsonSpec Valid JSON string that conforms to the automation schema.
+     */
+    public AutomationEngine(@NonNull String jsonSpec) {
+        mNativeObject = nCreateAutomationEngine(jsonSpec);
+        if (mNativeObject == 0) throw new IllegalStateException("Couldn't create AutomationEngine");
+    }
+
+    /**
+     * Creates an automation engine for the sole purpose of pushing settings, or for executing
+     * the default test sequence.
+     *
+     * To see how the default test sequence is generated, search for DEFAULT_AUTOMATION.
+     */
+    public AutomationEngine() {
+        mNativeObject = nCreateDefaultAutomationEngine();
+        if (mNativeObject == 0) throw new IllegalStateException("Couldn't create AutomationEngine");
+    }
+
+    /**
+     * Configures the automation engine for users who wish to set up a custom sleep time
+     * between tests, etc.
+     */
+    public void setOptions(@NonNull Options options) {
+        nSetOptions(mNativeObject, options.sleepDuration, options.minFrameCount, options.verbose);
+    }
+
+    /**
+     * Activates the automation test. During the subsequent call to tick(), the first test is
+     * applied and automation enters the running state.
+     */
+    public void startRunning() { nStartRunning(mNativeObject); }
+
+    /**
+     * Activates the automation test, but enters a paused state until the user calls
+     * signalBatchMode().
+     */
+    public void startBatchMode() { nStartBatchMode(mNativeObject); }
+
+    /**
+     * Notifies the automation engine that time has passed and a new frame has been rendered.
+     *
+     * This is when settings get applied, screenshots are (optionally) exported, and the internal
+     * test counter is potentially incremented.
+     *
+     * @param content       Contains the Filament View, Materials, and Renderer that get modified.
+     * @param deltaTime     The amount of time that has passed since the previous tick in seconds.
+     */
+    public void tick(@NonNull ViewerContent content, float deltaTime) {
+        if (content.view == null || content.renderer == null) {
+            throw new IllegalStateException("Must provide a View and Renderer");
+        }
+        long[] nativeMaterialInstances = null;
+        if (content.materials != null) {
+            nativeMaterialInstances = new long[content.materials.length];
+            for (int i = 0; i < nativeMaterialInstances.length; i++) {
+                nativeMaterialInstances[i] = content.materials[i].getNativeObject();
+            }
+        }
+        long nativeView = content.view.getNativeObject();
+        long nativeRenderer = content.renderer.getNativeObject();
+        nTick(mNativeObject, nativeView, nativeMaterialInstances, nativeRenderer, deltaTime);
+    }
+
+    /**
+     * Mutates a set of client-owned Filament objects according to a JSON string.
+     *
+     * This method is an alternative to tick(). It allows clients to use the automation engine as a
+     * remote control, as opposed to iterating through a predetermined test sequence.
+     *
+     * This updates the stashed Settings object, then pushes those settings to the given
+     * Filament objects. Clients can optionally call getColorGrading() after calling this method.
+     *
+     * @param settingsJson  Contains the JSON string with a set of changes that need to be pushed.
+     * @param content       Contains a set of Filament objects that you want to mutate.
+     */
+    public void applySettings(@NonNull String settingsJson, @NonNull ViewerContent content) {
+        if (content.view == null || content.renderer == null) {
+            throw new IllegalStateException("Must provide a View and Renderer");
+        }
+        long[] nativeMaterialInstances = null;
+        if (content.lightManager == null || content.scene == null) {
+            throw new IllegalStateException("Must provide a LightManager and Scene");
+        }
+        if (content.materials != null) {
+            nativeMaterialInstances = new long[content.materials.length];
+            for (int i = 0; i < nativeMaterialInstances.length; i++) {
+                nativeMaterialInstances[i] = content.materials[i].getNativeObject();
+            }
+        }
+        long nativeView = content.view.getNativeObject();
+        long nativeIbl = content.indirectLight == null ? 0 : content.indirectLight.getNativeObject();
+        long nativeLm = content.lightManager.getNativeObject();
+        long nativeScene = content.scene.getNativeObject();
+        long nativeRenderer = content.renderer.getNativeObject();
+        nApplySettings(mNativeObject, settingsJson, nativeView, nativeMaterialInstances,
+                nativeIbl, content.sunlight, content.assetLights, nativeLm, nativeScene,
+                nativeRenderer);
+    }
+
+    /**
+     * Gets the current viewer options.
+     *
+     * NOTE: Focal length here might be different from the user-specified value, due to DoF options.
+     */
+    @NonNull
+    public ViewerOptions getViewerOptions() {
+        ViewerOptions result = new ViewerOptions();
+        nGetViewerOptions(mNativeObject, result);
+        return result;
+    }
+
+    /**
+     * Gets a color grading object that corresponds to the latest settings.
+     *
+     * This method either returns a cached instance, or it destroys the cached instance and creates
+     * a new one.
+     */
+    @NonNull
+    public ColorGrading getColorGrading(@NonNull Engine engine) {
+        // The native layer automatically destroys the old color grading instance,
+        // so there is no need to call Engine#destroyColorGrading here.
+        long nativeCg = nGetColorGrading(mNativeObject, engine.getNativeObject());
+        if (mColorGrading == null || mColorGrading.getNativeObject() != nativeCg) {
+            mColorGrading = nativeCg == 0 ? null : new ColorGrading(nativeCg);
+        }
+        return mColorGrading;
+    }
+
+    /**
+     * Signals that batch mode can begin. Call this after all meshes and textures finish loading.
+     */
+    public void signalBatchMode() { nSignalBatchMode(mNativeObject); }
+
+    /**
+     * Cancels an in-progress automation session.
+     */
+    public void stopRunning() { nStopRunning(mNativeObject); }
+
+    /**
+     * Returns true if automation is in batch mode and all tests have finished.
+     */
+    public boolean shouldClose() { return nShouldClose(mNativeObject); }
+
+    @Override
+    protected void finalize() throws Throwable {
+        nDestroy(mNativeObject);
+        super.finalize();
+    }
+
+    private static native long nCreateAutomationEngine(String jsonSpec);
+    private static native long nCreateDefaultAutomationEngine();
+    private static native void nSetOptions(long nativeObject, float sleepDuration,
+            int minFrameCount, boolean verbose);
+    private static native void nStartRunning(long nativeObject);
+    private static native void nStartBatchMode(long nativeObject);
+    private static native void nTick(long nativeObject, long view, long[] materials, long renderer,
+            float deltaTime);
+    private static native void nApplySettings(long nativeObject, String jsonSettings, long view,
+            long[] materials, long ibl, int sunlight, int[] assetLights, long lightManager,
+            long scene, long renderer);
+    private static native void nGetViewerOptions(long nativeObject, Object result);
+    private static native long nGetColorGrading(long nativeObject, long nativeEngine);
+    private static native void nSignalBatchMode(long nativeObject);
+    private static native void nStopRunning(long nativeObject);
+    private static native boolean nShouldClose(long nativeObject);
+    private static native void nDestroy(long nativeObject);
+}

android/filament-utils-android/src/main/java/com/google/android/filament/utils/HDRLoader.kt

@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.android.filament.utils
+
+import com.google.android.filament.Engine
+import com.google.android.filament.Texture
+
+import java.nio.Buffer
+
+/**
+ * Utility for decoding an HDR file and producing a Filament texture.
+ */
+object HDRLoader {
+    class Options {
+        var desiredFormat = Texture.InternalFormat.RGB16F
+    }
+
+    /**
+     * Consumes the content of an HDR file and produces a [Texture] object.
+     *
+     * @param engine Gets passed to the builder.
+     * @param buffer The content of the HDR File.
+     * @param options Loader options.
+     * @return The resulting Filament texture, or null on failure.
+     */
+    fun createTexture(engine: Engine, buffer: Buffer, options: Options = Options()): Texture? {
+        val nativeEngine = engine.nativeObject
+        val nativeTexture = nCreateHDRTexture(nativeEngine, buffer, buffer.remaining(), options.desiredFormat.ordinal)
+        if (nativeTexture == 0L) {
+            return null;
+        }
+        return Texture(nativeTexture)
+    }
+
+    private external fun nCreateHDRTexture(nativeEngine: Long, buffer: Buffer, remaining: Int, format: Int): Long
+}

android/filament-utils-android/src/main/java/com/google/android/filament/utils/IBLPrefilterContext.java

@@ -0,0 +1,130 @@
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.android.filament.utils;
+
+import com.google.android.filament.Engine;
+import com.google.android.filament.Texture;
+
+/**
+ * IBLPrefilterContext creates and initializes GPU state common to all environment map filters
+ * supported. Typically, only one instance per filament Engine of this object needs to exist.
+ *
+ * Java usage example:
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ * context = new IBLPrefilterContext(engine);
+ * equirectangularToCubemap = new IBLPrefilterContext.EquirectangularToCubemap(context);
+ *
+ * Texture equirect = HDRLoader.createTexture("foo.hdr");
+ * Texture skyboxTexture = equirectangularToCubemap.run(equirect);
+ * engine.destroy(equirect);
+ * equirectangularToCubemap.destroy();
+ *
+ * specularFilter = new IBLPrefilterContext.SpecularFilter(context);
+ * Texture reflections = specularFilter.run(skyboxTexture);
+ * specularFilter.destroy();
+ *
+ * context.destroy();
+ *
+ * IndirectLight ibl = IndirectLight.Builder()
+ *         .reflections(reflections)
+ *         .intensity(30000.0f)
+ *         .build(engine);
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ */
+public class IBLPrefilterContext {
+    private long mNativeObject;
+
+    public IBLPrefilterContext(Engine engine) {
+        mNativeObject = nCreate(engine.getNativeObject());
+        if (mNativeObject == 0) throw new IllegalStateException("Couldn't create IBLPrefilterContext");
+    }
+
+    public void destroy() {
+        nDestroy(getNativeObject());
+        mNativeObject = 0;
+    }
+
+    public static class EquirectangularToCubemap {
+        private long mNativeObject;
+
+        public EquirectangularToCubemap(IBLPrefilterContext context) {
+            mNativeObject = nCreateEquirectHelper(context.getNativeObject());
+        }
+
+        public Texture run(Texture equirect) {
+            long nativeTexture = nEquirectHelperRun(getNativeObject(), equirect.getNativeObject());
+            return new Texture(nativeTexture);
+        }
+
+        public void destroy() {
+            nDestroyEquirectHelper(getNativeObject());
+            mNativeObject = 0;
+        }
+
+        protected long getNativeObject() {
+            if (mNativeObject == 0) {
+                throw new IllegalStateException("Calling method on destroyed EquirectangularToCubemap");
+            }
+            return mNativeObject;
+        }
+    }
+
+    public static class SpecularFilter {
+        private long mNativeObject;
+
+        public SpecularFilter(IBLPrefilterContext context) {
+            mNativeObject = nCreateSpecularFilter(context.getNativeObject());
+        }
+
+        public Texture run(Texture skybox) {
+            long nativeTexture = nSpecularFilterRun(getNativeObject(), skybox.getNativeObject());
+            return new Texture(nativeTexture);
+        }
+
+        public void destroy() {
+            nDestroySpecularFilter(getNativeObject());
+            mNativeObject = 0;
+        }
+
+        protected long getNativeObject() {
+            if (mNativeObject == 0) {
+                throw new IllegalStateException("Calling method on destroyed SpecularFilter");
+            }
+            return mNativeObject;
+        }
+    }
+
+
+    protected long getNativeObject() {
+        if (mNativeObject == 0) {
+            throw new IllegalStateException("Calling method on destroyed IBLPrefilterContext");
+        }
+        return mNativeObject;
+    }
+
+    private static native long nCreate(long nativeEngine);
+    private static native void nDestroy(long nativeObject);
+
+    private static native long nCreateEquirectHelper(long nativeContext);
+    private static native long nEquirectHelperRun(long nativeHelper, long nativeEquirect);
+    private static native void nDestroyEquirectHelper(long nativeObject);
+
+    private static native long nCreateSpecularFilter(long nativeContext);
+    private static native long nSpecularFilterRun(long nativeHelper, long nativeSkybox);
+    private static native void nDestroySpecularFilter(long nativeObject);
+}

android/filament-utils-android/src/main/java/com/google/android/filament/utils/KTXLoader.kt

@@ -29,7 +29,7 @@ import java.nio.Buffer
  * KTX is a simple container format that makes it easy to bundle miplevels and cubemap faces
  * into a single file.
  */
-object KtxLoader {
+object KTXLoader {
     class Options {
         var srgb = false
     }
@@ -44,8 +44,8 @@ object KtxLoader {
      */
     fun createTexture(engine: Engine, buffer: Buffer, options: Options = Options()): Texture {
         val nativeEngine = engine.nativeObject
-        val nativeTexture = nCreateTexture(nativeEngine, buffer, buffer.remaining(), options.srgb)
-        return Texture(engine, nativeTexture)
+        val nativeTexture = nCreateKTXTexture(nativeEngine, buffer, buffer.remaining(), options.srgb)
+        return Texture(nativeTexture)
     }
 
     /**
@@ -59,7 +59,7 @@ object KtxLoader {
     fun createIndirectLight(engine: Engine, buffer: Buffer, options: Options = Options()): IndirectLight {
         val nativeEngine = engine.nativeObject
         val nativeIndirectLight = nCreateIndirectLight(nativeEngine, buffer, buffer.remaining(), options.srgb)
-        return IndirectLight(engine, nativeIndirectLight)
+        return IndirectLight(nativeIndirectLight)
     }
 
     /**
@@ -73,10 +73,23 @@ object KtxLoader {
     fun createSkybox(engine: Engine, buffer: Buffer, options: Options = Options()): Skybox {
         val nativeEngine = engine.nativeObject
         val nativeSkybox = nCreateSkybox(nativeEngine, buffer, buffer.remaining(), options.srgb)
-        return Skybox(engine, nativeSkybox)
+        return Skybox(nativeSkybox)
     }
 
-    private external fun nCreateTexture(nativeEngine: Long, buffer: Buffer, remaining: Int, srgb: Boolean): Long
+    /**
+     * Retrieves spherical harmonics from the content of a KTX file.
+     *
+     * @param buffer The content of the KTX File.
+     * @return The resulting array of 9 * 3 floats, or null on failure.
+     */
+    fun getSphericalHarmonics(buffer: Buffer): FloatArray? {
+        val sphericalHarmonics = FloatArray(9 * 3)
+        val success = nGetSphericalHarmonics(buffer, buffer.remaining(), sphericalHarmonics)
+        return if (success) sphericalHarmonics else null
+    }
+
+    private external fun nCreateKTXTexture(nativeEngine: Long, buffer: Buffer, remaining: Int, srgb: Boolean): Long
     private external fun nCreateIndirectLight(nativeEngine: Long, buffer: Buffer, remaining: Int, srgb: Boolean): Long
+    private external fun nGetSphericalHarmonics(buffer: Buffer, remaining: Int, outSphericalHarmonics: FloatArray): Boolean
     private external fun nCreateSkybox(nativeEngine: Long, buffer: Buffer, remaining: Int, srgb: Boolean): Long
 }

android/filament-utils-android/src/main/java/com/google/android/filament/utils/Manipulator.java

@@ -32,7 +32,9 @@ import androidx.annotation.Size;
  * @see Bookmark
  */
 public class Manipulator {
-    private long mNativeObject;
+    private static final Mode[] sModeValues = Mode.values();
+
+    private final long mNativeObject;
 
     private Manipulator(long nativeIndexBuffer) {
         mNativeObject = nativeIndexBuffer;
@@ -199,7 +201,7 @@ public class Manipulator {
          * @return this <code>Builder</code> object for chaining calls
          */
         public Builder flightStartPosition(float x, float y, float z) {
-            nFlightStartPosition(mNativeBuilder, x, y, z);
+            nBuilderFlightStartPosition(mNativeBuilder, x, y, z);
             return this;
         }
 
@@ -209,7 +211,7 @@ public class Manipulator {
          * @return this <code>Builder</code> object for chaining calls
          */
         public Builder flightStartOrientation(float pitch, float yaw) {
-            nFlightStartOrientation(mNativeBuilder, pitch, yaw);
+            nBuilderFlightStartOrientation(mNativeBuilder, pitch, yaw);
             return this;
         }
 
@@ -220,7 +222,7 @@ public class Manipulator {
          * @return this <code>Builder</code> object for chaining calls
          */
         public Builder flightMaxMoveSpeed(float maxSpeed) {
-            nFlightMaxMoveSpeed(mNativeBuilder, maxSpeed);
+            nBuilderFlightMaxMoveSpeed(mNativeBuilder, maxSpeed);
             return this;
         }
 
@@ -231,7 +233,7 @@ public class Manipulator {
          * @return this <code>Builder</code> object for chaining calls
          */
         public Builder flightSpeedSteps(int steps) {
-            nFlightSpeedSteps(mNativeBuilder, steps);
+            nBuilderFlightSpeedSteps(mNativeBuilder, steps);
             return this;
         }
 
@@ -242,7 +244,7 @@ public class Manipulator {
         * @return this <code>Builder</code> object for chaining calls
         */
         public Builder flightPanSpeed(float x, float y) {
-            nFlightPanSpeed(mNativeBuilder, x, y);
+            nBuilderFlightPanSpeed(mNativeBuilder, x, y);
             return this;
         }
 
@@ -255,7 +257,7 @@ public class Manipulator {
         * @return this <code>Builder</code> object for chaining calls
         */
         public Builder flightMoveDamping(float damping) {
-            nFlightMoveDamping(mNativeBuilder, damping);
+            nBuilderFlightMoveDamping(mNativeBuilder, damping);
             return this;
         }
 
@@ -320,7 +322,7 @@ public class Manipulator {
     /**
      * Gets the immutable mode of the manipulator.
      */
-    public Mode getMode() { return Mode.values()[nGetMode(mNativeObject)]; }
+    public Mode getMode() { return sModeValues[nGetMode(mNativeObject)]; }
 
     /**
      * Sets the viewport dimensions in terms of pixels.
@@ -474,12 +476,12 @@ public class Manipulator {
     private static native void nBuilderFarPlane(long nativeBuilder, float distance);
     private static native void nBuilderMapExtent(long nativeBuilder, float width, float height);
     private static native void nBuilderMapMinDistance(long nativeBuilder, float arg);
-    private static native void nFlightStartPosition(long nativeBuilder, float x, float y, float z);
-    private static native void nFlightStartOrientation(long nativeBuilder, float pitch, float yaw);
-    private static native void nFlightMaxMoveSpeed(long nativeBuilder, float maxSpeed);
-    private static native void nFlightSpeedSteps(long nativeBuilder, int steps);
-    private static native void nFlightPanSpeed(long nativeBuilder, float x, float y);
-    private static native void nFlightMoveDamping(long nativeBuilder, float damping);
+    private static native void nBuilderFlightStartPosition(long nativeBuilder, float x, float y, float z);
+    private static native void nBuilderFlightStartOrientation(long nativeBuilder, float pitch, float yaw);
+    private static native void nBuilderFlightMaxMoveSpeed(long nativeBuilder, float maxSpeed);
+    private static native void nBuilderFlightSpeedSteps(long nativeBuilder, int steps);
+    private static native void nBuilderFlightPanSpeed(long nativeBuilder, float x, float y);
+    private static native void nBuilderFlightMoveDamping(long nativeBuilder, float damping);
     private static native void nBuilderGroundPlane(long nativeBuilder, float a, float b, float c, float d);
     private static native long nBuilderBuild(long nativeBuilder, int mode);
 

android/filament-utils-android/src/main/java/com/google/android/filament/utils/Matrix.kt

@@ -80,18 +80,22 @@ data class Mat2(
     operator fun times(v: Float) = Mat2(x * v, y * v)
     operator fun div(v: Float) = Mat2(x / v, y / v)
 
-    operator fun times(m: Mat2): Mat2 {
-        val t = transpose(this)
-        return Mat2(
-                Float2(dot(t.x, m.x), dot(t.y, m.x)),
-                Float2(dot(t.x, m.y), dot(t.y, m.y))
-        )
-    }
+    operator fun times(m: Mat2) = Mat2(
+            Float2(
+                    x.x * m.x.x + y.x * m.x.y,
+                    x.y * m.x.x + y.y * m.x.y,
+            ),
+            Float2(
+                    x.x * m.y.x + y.x * m.y.y,
+                    x.y * m.y.x + y.y * m.y.y,
+            )
+    )
+
+    operator fun times(v: Float2) = Float2(
+            x.x * v.x + y.x * v.y,
+            x.y * v.x + y.y * v.y,
+    )
 
-    operator fun times(v: Float2): Float2 {
-        val t = transpose(this)
-        return Float2(dot(t.x, v), dot(t.y, v))
-    }
 
     fun toFloatArray() = floatArrayOf(
             x.x, y.x,
@@ -171,19 +175,29 @@ data class Mat3(
     operator fun times(v: Float) = Mat3(x * v, y * v, z * v)
     operator fun div(v: Float) = Mat3(x / v, y / v, z / v)
 
-    operator fun times(m: Mat3): Mat3 {
-        val t = transpose(this)
-        return Mat3(
-                Float3(dot(t.x, m.x), dot(t.y, m.x), dot(t.z, m.x)),
-                Float3(dot(t.x, m.y), dot(t.y, m.y), dot(t.z, m.y)),
-                Float3(dot(t.x, m.z), dot(t.y, m.z), dot(t.z, m.z))
-        )
-    }
+    operator fun times(m: Mat3) = Mat3(
+            Float3(
+                    x.x * m.x.x + y.x * m.x.y + z.x * m.x.z,
+                    x.y * m.x.x + y.y * m.x.y + z.y * m.x.z,
+                    x.z * m.x.x + y.z * m.x.y + z.z * m.x.z,
+            ),
+            Float3(
+                    x.x * m.y.x + y.x * m.y.y + z.x * m.y.z,
+                    x.y * m.y.x + y.y * m.y.y + z.y * m.y.z,
+                    x.z * m.y.x + y.z * m.y.y + z.z * m.y.z,
+            ),
+            Float3(
+                    x.x * m.z.x + y.x * m.z.y + z.x * m.z.z,
+                    x.y * m.z.x + y.y * m.z.y + z.y * m.z.z,
+                    x.z * m.z.x + y.z * m.z.y + z.z * m.z.z,
+            )
+    )
 
-    operator fun times(v: Float3): Float3 {
-        val t = transpose(this)
-        return Float3(dot(t.x, v), dot(t.y, v), dot(t.z, v))
-    }
+    operator fun times(v: Float3) = Float3(
+            x.x * v.x + y.x * v.y + z.x * v.z,
+            x.y * v.x + y.y * v.y + z.y * v.z,
+            x.z * v.x + y.z * v.y + z.z * v.z,
+    )
 
     fun toFloatArray() = floatArrayOf(
             x.x, y.x, z.x,
@@ -313,20 +327,39 @@ data class Mat4(
     operator fun times(v: Float) = Mat4(x * v, y * v, z * v, w * v)
     operator fun div(v: Float) = Mat4(x / v, y / v, z / v, w / v)
 
-    operator fun times(m: Mat4): Mat4 {
-        val t = transpose(this)
-        return Mat4(
-                Float4(dot(t.x, m.x), dot(t.y, m.x), dot(t.z, m.x), dot(t.w, m.x)),
-                Float4(dot(t.x, m.y), dot(t.y, m.y), dot(t.z, m.y), dot(t.w, m.y)),
-                Float4(dot(t.x, m.z), dot(t.y, m.z), dot(t.z, m.z), dot(t.w, m.z)),
-                Float4(dot(t.x, m.w), dot(t.y, m.w), dot(t.z, m.w), dot(t.w, m.w))
-        )
-    }
+    operator fun times(m: Mat4) = Mat4(
+            Float4(
+                    x.x * m.x.x + y.x * m.x.y + z.x * m.x.z + w.x * m.x.w,
+                    x.y * m.x.x + y.y * m.x.y + z.y * m.x.z + w.y * m.x.w,
+                    x.z * m.x.x + y.z * m.x.y + z.z * m.x.z + w.z * m.x.w,
+                    x.w * m.x.x + y.w * m.x.y + z.w * m.x.z + w.w * m.x.w,
+            ),
+            Float4(
+                    x.x * m.y.x + y.x * m.y.y + z.x * m.y.z + w.x * m.y.w,
+                    x.y * m.y.x + y.y * m.y.y + z.y * m.y.z + w.y * m.y.w,
+                    x.z * m.y.x + y.z * m.y.y + z.z * m.y.z + w.z * m.y.w,
+                    x.w * m.y.x + y.w * m.y.y + z.w * m.y.z + w.w * m.y.w,
+            ),
+            Float4(
+                    x.x * m.z.x + y.x * m.z.y + z.x * m.z.z + w.x * m.z.w,
+                    x.y * m.z.x + y.y * m.z.y + z.y * m.z.z + w.y * m.z.w,
+                    x.z * m.z.x + y.z * m.z.y + z.z * m.z.z + w.z * m.z.w,
+                    x.w * m.z.x + y.w * m.z.y + z.w * m.z.z + w.w * m.z.w,
+            ),
+            Float4(
+                    x.x * m.w.x + y.x * m.w.y + z.x * m.w.z + w.x * m.w.w,
+                    x.y * m.w.x + y.y * m.w.y + z.y * m.w.z + w.y * m.w.w,
+                    x.z * m.w.x + y.z * m.w.y + z.z * m.w.z + w.z * m.w.w,
+                    x.w * m.w.x + y.w * m.w.y + z.w * m.w.z + w.w * m.w.w,
+            )
+    )
 
-    operator fun times(v: Float4): Float4 {
-        val t = transpose(this)
-        return Float4(dot(t.x, v), dot(t.y, v), dot(t.z, v), dot(t.w, v))
-    }
+    operator fun times(v: Float4) = Float4(
+            x.x * v.x + y.x * v.y + z.x * v.z+ w.x * v.w,
+            x.y * v.x + y.y * v.y + z.y * v.z+ w.y * v.w,
+            x.z * v.x + y.z * v.y + z.z * v.z+ w.z * v.w,
+            x.w * v.x + y.w * v.y + z.w * v.z+ w.w * v.w
+    )
 
     fun toFloatArray() = floatArrayOf(
             x.x, y.x, z.x, w.x,
@@ -355,6 +388,8 @@ fun transpose(m: Mat3) = Mat3(
         Float3(m.x.y, m.y.y, m.z.y),
         Float3(m.x.z, m.y.z, m.z.z)
 )
+
+@Suppress("LocalVariableName")
 fun inverse(m: Mat3): Mat3 {
     val a = m.x.x
     val b = m.x.y
@@ -385,6 +420,7 @@ fun transpose(m: Mat4) = Mat4(
         Float4(m.x.z, m.y.z, m.z.z, m.w.z),
         Float4(m.x.w, m.y.w, m.z.w, m.w.w)
 )
+
 fun inverse(m: Mat4): Mat4 {
     val result = Mat4()
 
@@ -462,8 +498,8 @@ fun translation(m: Mat4) = translation(m.translation)
 fun rotation(m: Mat4) = Mat4(normalize(m.right), normalize(m.up), normalize(m.forward))
 fun rotation(d: Float3): Mat4 {
     val r = transform(d, ::radians)
-    val c = transform(r, { x -> cos(x) })
-    val s = transform(r, { x -> sin(x) })
+    val c = transform(r) { x -> cos(x) }
+    val s = transform(r) { x -> sin(x) }
 
     return Mat4.of(
              c.y * c.z, -c.x * s.z + s.x * s.y * c.z,  s.x * s.z + c.x * s.y * c.z, 0.0f,

android/filament-utils-android/src/main/java/com/google/android/filament/utils/ModelViewer.kt

@@ -27,9 +27,8 @@ import com.google.android.filament.gltfio.*
 import kotlinx.coroutines.*
 import java.nio.Buffer
 
-private const val kNearPlane = 0.5
-private const val kFarPlane = 10000.0
-private const val kFovDegrees = 45.0
+private const val kNearPlane = 0.05     // 5 cm
+private const val kFarPlane = 1000.0    // 1 km
 private const val kAperture = 16f
 private const val kShutterSpeed = 1f / 125f
 private const val kSensitivity = 100f
@@ -59,7 +58,10 @@ private const val kSensitivity = 100f
  *
  * See `sample-gltf-viewer` for a usage example.
  */
-class ModelViewer(val engine: Engine) : android.view.View.OnTouchListener {
+class ModelViewer(
+        val engine: Engine,
+        private val uiHelper: UiHelper
+) : android.view.View.OnTouchListener {
     var asset: FilamentAsset? = null
         private set
 
@@ -72,20 +74,28 @@ class ModelViewer(val engine: Engine) : android.view.View.OnTouchListener {
 
     var normalizeSkinningWeights = true
     var recomputeBoundingBoxes = false
+    var ignoreBindTransform = false
+
+    var cameraFocalLength = 28f
+        set(value) {
+            field = value
+            updateCameraProjection()
+        }
 
     val scene: Scene
     val view: View
     val camera: Camera
+    val renderer: Renderer
     @Entity val light: Int
 
-    private val uiHelper: UiHelper = UiHelper(UiHelper.ContextErrorPolicy.DONT_CHECK)
     private lateinit var displayHelper: DisplayHelper
     private lateinit var cameraManipulator: Manipulator
     private lateinit var gestureDetector: GestureDetector
     private var surfaceView: SurfaceView? = null
     private var textureView: TextureView? = null
 
-    private val renderer: Renderer
+    private var fetchResourcesJob: Job? = null
+
     private var swapChain: SwapChain? = null
     private var assetLoader: AssetLoader
     private var resourceLoader: ResourceLoader
@@ -98,13 +108,13 @@ class ModelViewer(val engine: Engine) : android.view.View.OnTouchListener {
     init {
         renderer = engine.createRenderer()
         scene = engine.createScene()
-        camera = engine.createCamera().apply { setExposure(kAperture, kShutterSpeed, kSensitivity) }
+        camera = engine.createCamera(engine.entityManager.create()).apply { setExposure(kAperture, kShutterSpeed, kSensitivity) }
         view = engine.createView()
         view.scene = scene
         view.camera = camera
 
-        assetLoader = AssetLoader(engine, MaterialProvider(engine), EntityManager.get())
-        resourceLoader = ResourceLoader(engine, normalizeSkinningWeights, recomputeBoundingBoxes)
+        assetLoader = AssetLoader(engine, UbershaderLoader(engine), EntityManager.get())
+        resourceLoader = ResourceLoader(engine, normalizeSkinningWeights, recomputeBoundingBoxes, ignoreBindTransform)
 
         // Always add a direct light source since it is required for shadowing.
         // We highly recommend adding an indirect light as well.
@@ -122,7 +132,12 @@ class ModelViewer(val engine: Engine) : android.view.View.OnTouchListener {
         scene.addEntity(light)
     }
 
-    constructor(surfaceView: SurfaceView, engine: Engine = Engine.create(), manipulator: Manipulator? = null) : this(engine) {
+    constructor(
+            surfaceView: SurfaceView,
+            engine: Engine = Engine.create(),
+            uiHelper: UiHelper = UiHelper(UiHelper.ContextErrorPolicy.DONT_CHECK),
+            manipulator: Manipulator? = null
+    ) : this(engine, uiHelper) {
         cameraManipulator = manipulator ?: Manipulator.Builder()
                 .targetPosition(kDefaultObjectPosition.x, kDefaultObjectPosition.y, kDefaultObjectPosition.z)
                 .viewport(surfaceView.width, surfaceView.height)
@@ -137,7 +152,12 @@ class ModelViewer(val engine: Engine) : android.view.View.OnTouchListener {
     }
 
     @Suppress("unused")
-    constructor(textureView: TextureView, engine: Engine = Engine.create(), manipulator: Manipulator? = null) : this(engine) {
+    constructor(
+            textureView: TextureView,
+            engine: Engine = Engine.create(),
+            uiHelper: UiHelper = UiHelper(UiHelper.ContextErrorPolicy.DONT_CHECK),
+            manipulator: Manipulator? = null
+    ) : this(engine, uiHelper) {
         cameraManipulator = manipulator ?: Manipulator.Builder()
                 .targetPosition(kDefaultObjectPosition.x, kDefaultObjectPosition.y, kDefaultObjectPosition.z)
                 .viewport(textureView.width, textureView.height)
@@ -169,12 +189,17 @@ class ModelViewer(val engine: Engine) : android.view.View.OnTouchListener {
      *
      * The given callback is triggered for each requested resource.
      */
-    fun loadModelGltf(buffer: Buffer, callback: (String) -> Buffer) {
+    fun loadModelGltf(buffer: Buffer, callback: (String) -> Buffer?) {
         destroyModel()
         asset = assetLoader.createAssetFromJson(buffer)
         asset?.let { asset ->
             for (uri in asset.resourceUris) {
-                resourceLoader.addResourceData(uri, callback(uri))
+                val resourceBuffer = callback(uri)
+                if (resourceBuffer == null) {
+                    this.asset = null
+                    return
+                }
+                resourceLoader.addResourceData(uri, resourceBuffer)
             }
             resourceLoader.asyncBeginLoad(asset)
             animator = asset.animator
@@ -190,7 +215,7 @@ class ModelViewer(val engine: Engine) : android.view.View.OnTouchListener {
     fun loadModelGltfAsync(buffer: Buffer, callback: (String) -> Buffer) {
         destroyModel()
         asset = assetLoader.createAssetFromJson(buffer)
-        CoroutineScope(Dispatchers.IO).launch {
+        fetchResourcesJob = CoroutineScope(Dispatchers.IO).launch {
             fetchResources(asset!!, callback)
         }
     }
@@ -203,8 +228,8 @@ class ModelViewer(val engine: Engine) : android.view.View.OnTouchListener {
     fun transformToUnitCube(centerPoint: Float3 = kDefaultObjectPosition) {
         asset?.let { asset ->
             val tm = engine.transformManager
-            var center = asset.boundingBox.center.let { v-> Float3(v[0], v[1], v[2]) }
-            val halfExtent = asset.boundingBox.halfExtent.let { v-> Float3(v[0], v[1], v[2]) }
+            var center = asset.boundingBox.center.let { v -> Float3(v[0], v[1], v[2]) }
+            val halfExtent = asset.boundingBox.halfExtent.let { v -> Float3(v[0], v[1], v[2]) }
             val maxExtent = 2.0f * max(halfExtent)
             val scaleFactor = 2.0f / maxExtent
             center -= centerPoint / scaleFactor
@@ -213,10 +238,23 @@ class ModelViewer(val engine: Engine) : android.view.View.OnTouchListener {
         }
     }
 
+    /**
+     * Removes the transformation that was set up via transformToUnitCube.
+     */
+    fun clearRootTransform() {
+        asset?.let {
+            val tm = engine.transformManager
+            tm.setTransform(tm.getInstance(it.root), Mat4().toFloatArray())
+        }
+    }
+
     /**
      * Frees all entities associated with the most recently-loaded model.
      */
     fun destroyModel() {
+        fetchResourcesJob?.cancel()
+        resourceLoader.asyncCancelLoad()
+        resourceLoader.evictResourceData()
         asset?.let { asset ->
             this.scene.removeEntities(asset.entities)
             assetLoader.destroyAsset(asset)
@@ -257,9 +295,14 @@ class ModelViewer(val engine: Engine) : android.view.View.OnTouchListener {
     }
 
     private fun populateScene(asset: FilamentAsset) {
+        val rcm = engine.renderableManager
         var count = 0
-        val popRenderables = {count = asset.popRenderables(readyRenderables); count != 0}
+        val popRenderables = { count = asset.popRenderables(readyRenderables); count != 0 }
         while (popRenderables()) {
+            for (i in 0..count - 1) {
+                val ri = rcm.getInstance(readyRenderables[i])
+                rcm.setScreenSpaceContactShadows(ri, true)
+            }
             scene.addEntities(readyRenderables.take(count).toIntArray())
         }
         scene.addEntities(asset.lightEntities)
@@ -279,7 +322,8 @@ class ModelViewer(val engine: Engine) : android.view.View.OnTouchListener {
                 engine.destroyRenderer(renderer)
                 engine.destroyView(this@ModelViewer.view)
                 engine.destroyScene(scene)
-                engine.destroyCamera(camera)
+                engine.destroyCameraComponent(camera.entity)
+                EntityManager.get().destroy(camera.entity)
 
                 EntityManager.get().destroy(light)
 
@@ -318,6 +362,13 @@ class ModelViewer(val engine: Engine) : android.view.View.OnTouchListener {
         }
     }
 
+    private fun updateCameraProjection() {
+        val width = view.viewport.width
+        val height = view.viewport.height
+        val aspect = width.toDouble() / height.toDouble()
+        camera.setLensProjection(cameraFocalLength.toDouble(), aspect, kNearPlane, kFarPlane)
+    }
+
     inner class SurfaceCallback : UiHelper.RendererCallback {
         override fun onNativeWindowChanged(surface: Surface) {
             swapChain?.let { engine.destroySwapChain(it) }
@@ -337,13 +388,12 @@ class ModelViewer(val engine: Engine) : android.view.View.OnTouchListener {
 
         override fun onResized(width: Int, height: Int) {
             view.viewport = Viewport(0, 0, width, height)
-            val aspect = width.toDouble() / height.toDouble()
-            camera.setProjection(kFovDegrees, aspect, kNearPlane, kFarPlane, Camera.Fov.VERTICAL)
             cameraManipulator.setViewport(width, height)
+            updateCameraProjection()
         }
     }
 
     companion object {
         private val kDefaultObjectPosition = Float3(0.0f, 0.0f, -4.0f)
     }
-}
+}

android/filament-utils-android/src/main/java/com/google/android/filament/utils/RemoteServer.java

@@ -0,0 +1,106 @@
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.android.filament.utils;
+
+import androidx.annotation.Nullable;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+/**
+ * Manages a tiny WebSocket server that can receive model data and viewer settings.
+ *
+ * Client apps can call acquireReceivedMessage to check for new data and pop it off the small
+ * internal queue.
+ */
+public class RemoteServer {
+    private long mNativeObject;
+
+    /**
+    * Encapsulates a message sent from the web client.
+    */
+    public static class ReceivedMessage {
+        public String label;
+        public ByteBuffer buffer;
+    }
+
+    public RemoteServer(int port) {
+        mNativeObject = nCreate(port);
+        if (mNativeObject == 0) throw new IllegalStateException("Couldn't create RemoteServer");
+    }
+
+    /**
+     * Checks if a download is currently in progress and returns its label.
+     * Returns null if nothing is being downloaded.
+     */
+    public @Nullable String peekIncomingLabel() {
+        return nPeekIncomingLabel(mNativeObject);
+    }
+
+    /**
+     * Checks if a peeked message has JSON content.
+     */
+    public static boolean isJson(@Nullable String label) {
+        return label != null && label.endsWith(".json");
+    }
+
+    /**
+     * Checks if a peeked message has binary content.
+     */
+    public static boolean isBinary(@Nullable String label) {
+        return label != null && !label.endsWith(".json");
+    }
+
+    /**
+     * Pops a message off the incoming queue or returns null if there are no unread messages.
+     */
+    public @Nullable ReceivedMessage acquireReceivedMessage() {
+        int length = nPeekReceivedBufferLength(mNativeObject);
+        if (length == 0) {
+            return null;
+        }
+        ReceivedMessage message = new ReceivedMessage();
+        message.label = nPeekReceivedLabel(mNativeObject);
+        message.buffer = ByteBuffer.allocateDirect(length);
+        message.buffer.order(ByteOrder.LITTLE_ENDIAN);
+        nAcquireReceivedMessage(mNativeObject, message.buffer, length);
+        return message;
+    }
+
+    /*
+     * Destroys the native WebSocket server and frees up the port.
+     *
+     * This might need to be done explicitly (as opposed to waiting for gc) to free up the port.
+     */
+    public void close() {
+        nDestroy(mNativeObject);
+        mNativeObject = 0;
+    }
+
+    @Override
+    protected void finalize() throws Throwable {
+        nDestroy(mNativeObject);
+        super.finalize();
+    }
+
+    private static native long nCreate(int port);
+    private static native String nPeekIncomingLabel(long nativeObject);
+    private static native String nPeekReceivedLabel(long nativeObject);
+    private static native int nPeekReceivedBufferLength(long nativeObject);
+    private static native void nAcquireReceivedMessage(long nativeObject, ByteBuffer buffer, int length);
+    private static native void nDestroy(long nativeObject);
+}

android/gltfio-android/CMakeLists.txt

@@ -1,4 +1,5 @@
-cmake_minimum_required(VERSION 3.6)
+cmake_minimum_required(VERSION 3.19)
+project(gltfio-android)
 
 set(FILAMENT_DIR ${FILAMENT_DIST_DIR})
 set(GLTFIO_DIR ../../libs/gltfio)
@@ -29,7 +30,6 @@ set(GLTFIO_SRCS
         ${GLTFIO_DIR}/include/gltfio/AssetLoader.h
         ${GLTFIO_DIR}/include/gltfio/MaterialProvider.h
         ${GLTFIO_DIR}/include/gltfio/ResourceLoader.h
-        ${GLTFIO_DIR}/include/gltfio/SimpleViewer.h
         ${GLTFIO_DIR}/include/gltfio/FilamentAsset.h
         ${GLTFIO_DIR}/include/gltfio/FilamentInstance.h
 
@@ -45,7 +45,11 @@ set(GLTFIO_SRCS
         ${GLTFIO_DIR}/src/FilamentInstance.cpp
         ${GLTFIO_DIR}/src/GltfEnums.h
         ${GLTFIO_DIR}/src/MaterialProvider.cpp
+        ${GLTFIO_DIR}/src/MorphHelper.h
+        ${GLTFIO_DIR}/src/MorphHelper.cpp
         ${GLTFIO_DIR}/src/ResourceLoader.cpp
+        ${GLTFIO_DIR}/src/TangentsJob.h
+        ${GLTFIO_DIR}/src/TangentsJob.cpp
         ${GLTFIO_DIR}/src/UbershaderLoader.cpp
         ${GLTFIO_DIR}/src/Wireframe.cpp
         ${GLTFIO_DIR}/src/Wireframe.h
@@ -57,7 +61,9 @@ set(GLTFIO_SRCS
         src/main/cpp/AssetLoader.cpp
         src/main/cpp/FilamentAsset.cpp
         src/main/cpp/FilamentInstance.cpp
-        src/main/cpp/MaterialProvider.cpp
+        src/main/cpp/MaterialKey.cpp
+        src/main/cpp/MaterialKey.h
+        src/main/cpp/UbershaderLoader.cpp
         src/main/cpp/ResourceLoader.cpp
 
         ${FILAMENT_DIR}/include/gltfio/resources/gltfresources_lite.h
@@ -70,6 +76,8 @@ set(GLTFIO_INCLUDE_DIRS
         ..
         ${FILAMENT_DIR}/include
         ${FILAMENT_DIR}/include/gltfio/resources
+        ../../filament/backend/include
+        ../../libs/gltfio/include
         ../../third_party/cgltf
         ../../third_party/robin-map
         ../../third_party/hat-trie

android/gltfio-android/build.gradle

@@ -27,7 +27,8 @@ android {
 
 dependencies {
     implementation deps.androidx.annotations
-    implementation project(':filament-android')
+
+    api project(':filament-android')
 }
 
 apply from: rootProject.file('gradle/gradle-mvn-push.gradle')

android/gltfio-android/src/main/cpp/AssetLoader.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2019 The Android Open Source Project
+ * Copyright (C) 2021 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -23,27 +23,178 @@
 
 #include <gltfio/AssetLoader.h>
 #include <gltfio/MaterialProvider.h>
+#include <utils/debug.h>
 
 #include "common/NioUtils.h"
 
+#include "MaterialKey.h"
+
 using namespace filament;
 using namespace gltfio;
 using namespace utils;
 
+class JavaMaterialProvider : public MaterialProvider {
+    JNIEnv* const mEnv;
+    const jobject mJavaProvider;
+    mutable Material** mPreviousMaterials = nullptr;
+
+    jclass mMaterialKeyClass;
+
+    jmethodID mMaterialKeyConstructor;
+    jmethodID mCreateMaterialInstance;
+    jmethodID mGetMaterials;
+    jmethodID mNeedsDummyData;
+    jmethodID mDestroyMaterials;
+    jmethodID mMaterialInstanceGetNativeObject;
+    jmethodID mMaterialGetNativeObject;
+
+public:
+    JavaMaterialProvider(JNIEnv* env, jobject provider) : mEnv(env),
+            mJavaProvider(env->NewGlobalRef(provider)) {
+        mMaterialKeyClass = env->FindClass(JAVA_MATERIAL_KEY);
+        mMaterialKeyClass = (jclass) env->NewGlobalRef(mMaterialKeyClass);
+        assert_invariant(mMaterialKeyClass);
+
+        mMaterialKeyConstructor = env->GetMethodID(mMaterialKeyClass, "<init>", "()V");
+        assert_invariant(mMaterialKeyConstructor);
+
+        jclass materialInstanceClass = env->FindClass("com/google/android/filament/MaterialInstance");
+        mMaterialInstanceGetNativeObject = env->GetMethodID(materialInstanceClass, "getNativeObject", "()J");
+        assert_invariant(mMaterialInstanceGetNativeObject);
+
+        jclass materialClass = env->FindClass("com/google/android/filament/Material");
+        mMaterialGetNativeObject = env->GetMethodID(materialClass, "getNativeObject", "()J");
+        assert_invariant(mMaterialGetNativeObject);
+
+        jclass providerClass = env->GetObjectClass(provider);
+
+        mCreateMaterialInstance = env->GetMethodID(providerClass, "createMaterialInstance",
+                "(L" JAVA_MATERIAL_KEY ";[ILjava/lang/String;)Lcom/google/android/filament/MaterialInstance;");
+        assert_invariant(mCreateMaterialInstance);
+
+        mGetMaterials = env->GetMethodID(providerClass, "getMaterials",
+                "()[Lcom/google/android/filament/Material;");
+        assert_invariant(mGetMaterials);
+
+        mNeedsDummyData = env->GetMethodID(providerClass, "needsDummyData","(I)Z");
+        assert_invariant(mNeedsDummyData);
+
+        mDestroyMaterials = env->GetMethodID(providerClass, "destroyMaterials", "()V");
+        assert_invariant(mDestroyMaterials);
+    }
+
+    ~JavaMaterialProvider() override {
+        mEnv->DeleteGlobalRef(mMaterialKeyClass);
+        mEnv->DeleteGlobalRef(mJavaProvider);
+        delete mPreviousMaterials;
+    }
+
+    MaterialInstance* createMaterialInstance(MaterialKey* config, UvMap* uvmap, const char* label) override {
+        // Create a Java object for the material key and copy the native fields into it.
+        jobject javaKey = mEnv->NewObject(mMaterialKeyClass, mMaterialKeyConstructor);
+
+        auto& helper = MaterialKeyHelper::get();
+        helper.copy(mEnv, javaKey, *config);
+
+        // Convert the optional label into a Java string.
+        jstring stringLabel = label ? mEnv->NewStringUTF(label) : nullptr;
+
+        // Allocate space for the output argument.
+        jintArray uvMapArray = mEnv->NewIntArray(8);
+
+        // Call the Java-based material provider.
+        jobject materialInstance = mEnv->CallObjectMethod(mJavaProvider, mCreateMaterialInstance,
+                javaKey, uvMapArray, stringLabel);
+
+        // Copy the UvMap results from the JVM array into the native array.
+        if (uvmap) {
+            jint* elements = mEnv->GetIntArrayElements(uvMapArray, nullptr);
+            for (size_t i = 0; i < uvmap->size(); i++) {
+                (*uvmap)[i] = (UvSet) elements[i];
+            }
+            mEnv->ReleaseIntArrayElements(uvMapArray, elements, JNI_ABORT);
+        }
+
+        // The config parameter is an in-out parameter so we need to copy the results from Java.
+        helper.copy(mEnv, *config, javaKey);
+
+        mEnv->DeleteLocalRef(javaKey);
+        mEnv->DeleteLocalRef(uvMapArray);
+
+        if (stringLabel) {
+            mEnv->DeleteLocalRef(stringLabel);
+        }
+
+        if (materialInstance == nullptr) {
+            return nullptr;
+        }
+
+        return (MaterialInstance*) mEnv->CallLongMethod(materialInstance, mMaterialInstanceGetNativeObject);
+    }
+
+    const Material* const* getMaterials() const noexcept override {
+        jobjectArray javaMaterials = (jobjectArray) mEnv->CallObjectMethod(mJavaProvider, mGetMaterials);
+
+        const size_t count = mEnv->GetArrayLength(javaMaterials);
+
+        delete mPreviousMaterials;
+        using MaterialPointer = Material*;
+        mPreviousMaterials = new MaterialPointer[count];
+
+        // Call "getNativeObject" on each material in order to pass them up into the native layer.
+        for (size_t i = 0; i < count; ++i) {
+            jobject javaMaterial = mEnv->GetObjectArrayElement(javaMaterials, i);
+            jlong matPointer = mEnv->CallLongMethod(javaMaterial, mMaterialGetNativeObject);
+            mPreviousMaterials[i] = (Material*) matPointer;
+        }
+
+        return mPreviousMaterials;
+    }
+
+    size_t getMaterialsCount() const noexcept override {
+        jobjectArray javaMaterials = (jobjectArray) mEnv->CallObjectMethod(mJavaProvider, mGetMaterials);
+        return mEnv->GetArrayLength(javaMaterials);
+    }
+
+    void destroyMaterials() override {
+        mEnv->CallObjectMethod(mJavaProvider, mDestroyMaterials);
+    }
+
+    bool needsDummyData(VertexAttribute attrib) const noexcept override {
+        return mEnv->CallBooleanMethod(mJavaProvider, mNeedsDummyData, (int) attrib);
+    }
+};
+
 extern "C" JNIEXPORT jlong JNICALL
-Java_com_google_android_filament_gltfio_AssetLoader_nCreateAssetLoader(JNIEnv*, jclass,
-        jlong nativeEngine, jlong nativeProvider, jlong nativeEntities) {
+Java_com_google_android_filament_gltfio_AssetLoader_nCreateAssetLoader(JNIEnv* env, jclass,
+        jlong nativeEngine, jobject provider, jlong nativeEntities) {
     Engine* engine = (Engine*) nativeEngine;
-    MaterialProvider* materials = (MaterialProvider*) nativeProvider;
+    MaterialProvider* materialProvider = nullptr;
+
+    // First check for a fast path that passes a native MaterialProvider into the loader.
+    // This drastically reduces the number of JNI calls while the asset is being loaded.
+    jclass klass = env->GetObjectClass(provider);
+    jmethodID getNativeObject = env->GetMethodID(klass, "getNativeObject", "()J");
+    if (getNativeObject) {
+        materialProvider = (MaterialProvider*) env->CallLongMethod(provider, getNativeObject);
+    } else {
+        env->ExceptionClear();
+    }
+
+    if (materialProvider == nullptr) {
+        materialProvider = new JavaMaterialProvider(env, provider);
+    }
+
     EntityManager* entities = (EntityManager*) nativeEntities;
     NameComponentManager* names = new NameComponentManager(*entities);
-    return (jlong) AssetLoader::create({engine, materials, names, entities});
+    return (jlong) AssetLoader::create({engine, materialProvider, names, entities});
 }
 
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_gltfio_AssetLoader_nDestroyAssetLoader(JNIEnv*, jclass,
         jlong nativeLoader) {
     AssetLoader* loader = (AssetLoader*) nativeLoader;
+    delete loader->getMaterialProvider();
     NameComponentManager* names = loader->getNames();
     AssetLoader::destroy(&loader);
     delete names;
@@ -88,6 +239,14 @@ Java_com_google_android_filament_gltfio_AssetLoader_nCreateInstancedAsset(JNIEnv
     return asset;
 }
 
+extern "C" JNIEXPORT jlong JNICALL
+Java_com_google_android_filament_gltfio_AssetLoader_nCreateInstance(JNIEnv* env, jclass,
+        jlong nativeLoader, jlong nativeAsset) {
+    AssetLoader* loader = (AssetLoader*) nativeLoader;
+    FilamentAsset* primary = (FilamentAsset*) nativeAsset;
+    return (jlong) loader->createInstance(primary);
+}
+
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_gltfio_AssetLoader_nEnableDiagnostics(JNIEnv*, jclass,
         jlong nativeLoader, jboolean enable) {

android/gltfio-android/src/main/cpp/FilamentAsset.cpp

@@ -192,6 +192,15 @@ Java_com_google_android_filament_gltfio_FilamentAsset_nGetName(JNIEnv* env, jcla
     return val ? env->NewStringUTF(val) : nullptr;
 }
 
+extern "C" JNIEXPORT jstring JNICALL
+Java_com_google_android_filament_gltfio_FilamentAsset_nGetExtras(JNIEnv* env, jclass,
+        jlong nativeAsset, jint entityId) {
+    Entity entity = Entity::import(entityId);
+    FilamentAsset* asset = (FilamentAsset*) nativeAsset;
+    const auto val = asset->getExtras(entity);
+    return val ? env->NewStringUTF(val) : nullptr;
+}
+
 extern "C" JNIEXPORT jlong JNICALL
 Java_com_google_android_filament_gltfio_FilamentAsset_nGetAnimator(JNIEnv* , jclass,
         jlong nativeAsset) {

android/gltfio-android/src/main/cpp/MaterialKey.cpp

@@ -0,0 +1,177 @@
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <jni.h>
+
+#include <gltfio/MaterialProvider.h>
+
+#include "MaterialKey.h"
+
+using namespace gltfio;
+
+MaterialKeyHelper& MaterialKeyHelper::get() {
+    static MaterialKeyHelper helper;
+    return helper;
+}
+
+void MaterialKeyHelper::init(JNIEnv* env) {
+    const jclass materialKeyClass = env->FindClass(JAVA_MATERIAL_KEY);
+    auto field = [materialKeyClass, env](const char* fieldName, const char* signature) {
+        return env->GetFieldID(materialKeyClass, fieldName, signature);
+    };
+    doubleSided = field("doubleSided", "Z");
+    unlit = field("unlit", "Z");
+    hasVertexColors = field("hasVertexColors", "Z");
+    hasBaseColorTexture = field("hasBaseColorTexture", "Z");
+    hasNormalTexture = field("hasNormalTexture", "Z");
+    hasOcclusionTexture = field("hasOcclusionTexture", "Z");
+    hasEmissiveTexture = field("hasEmissiveTexture", "Z");
+    useSpecularGlossiness = field("useSpecularGlossiness", "Z");
+    alphaMode = field("alphaMode", "I");
+    enableDiagnostics = field("enableDiagnostics", "Z");
+    hasMetallicRoughnessTexture = field("hasMetallicRoughnessTexture", "Z");
+    metallicRoughnessUV = field("metallicRoughnessUV", "I");
+    baseColorUV = field("baseColorUV", "I");
+    hasClearCoatTexture = field("hasClearCoatTexture", "Z");
+    clearCoatUV = field("clearCoatUV", "I");
+    hasClearCoatRoughnessTexture = field("hasClearCoatRoughnessTexture", "Z");
+    clearCoatRoughnessUV = field("clearCoatRoughnessUV", "I");
+    hasClearCoatNormalTexture = field("hasClearCoatNormalTexture", "Z");
+    clearCoatNormalUV = field("clearCoatNormalUV", "I");
+    hasClearCoat = field("hasClearCoat", "Z");
+    hasTransmission = field("hasTransmission", "Z");
+    hasTextureTransforms = field("hasTextureTransforms", "Z");
+    emissiveUV = field("emissiveUV", "I");
+    aoUV = field("aoUV", "I");
+    normalUV = field("normalUV", "I");
+    hasTransmissionTexture = field("hasTransmissionTexture", "Z");
+    transmissionUV = field("transmissionUV", "I");
+    hasSheenColorTexture = field("hasSheenColorTexture", "Z");
+    sheenColorUV = field("sheenColorUV", "I");
+    hasSheenRoughnessTexture = field("hasSheenRoughnessTexture", "Z");
+    sheenRoughnessUV = field("sheenRoughnessUV", "I");
+    hasVolumeThicknessTexture = field("hasVolumeThicknessTexture", "Z");
+    volumeThicknessUV = field("volumeThicknessUV", "I");
+    hasSheen = field("hasSheen", "Z");
+    hasIOR = field("hasIOR", "Z");
+}
+
+void MaterialKeyHelper::copy(JNIEnv* env, MaterialKey& dst, jobject src) {
+    dst.doubleSided = env->GetBooleanField(src, doubleSided);
+    dst.unlit = env->GetBooleanField(src, unlit);
+    dst.hasVertexColors = env->GetBooleanField(src, hasVertexColors);
+    dst.hasBaseColorTexture = env->GetBooleanField(src, hasBaseColorTexture);
+    dst.hasNormalTexture = env->GetBooleanField(src, hasNormalTexture);
+    dst.hasOcclusionTexture = env->GetBooleanField(src, hasOcclusionTexture);
+    dst.hasEmissiveTexture = env->GetBooleanField(src, hasEmissiveTexture);
+    dst.useSpecularGlossiness = env->GetBooleanField(src, useSpecularGlossiness);
+    dst.alphaMode = (AlphaMode) env->GetIntField(src, alphaMode);
+    dst.enableDiagnostics = env->GetBooleanField(src, enableDiagnostics);
+    dst.hasMetallicRoughnessTexture = env->GetBooleanField(src, hasMetallicRoughnessTexture);
+    dst.metallicRoughnessUV = env->GetIntField(src, metallicRoughnessUV);
+    dst.baseColorUV = env->GetIntField(src, baseColorUV);
+    dst.hasClearCoatTexture = env->GetBooleanField(src, hasClearCoatTexture);
+    dst.clearCoatUV = env->GetIntField(src, clearCoatUV);
+    dst.hasClearCoatRoughnessTexture = env->GetBooleanField(src, hasClearCoatRoughnessTexture);
+    dst.clearCoatRoughnessUV = env->GetIntField(src, clearCoatRoughnessUV);
+    dst.hasClearCoatNormalTexture = env->GetBooleanField(src, hasClearCoatNormalTexture);
+    dst.clearCoatNormalUV = env->GetIntField(src, clearCoatNormalUV);
+    dst.hasClearCoat = env->GetBooleanField(src, hasClearCoat);
+    dst.hasTransmission = env->GetBooleanField(src, hasTransmission);
+    dst.hasTextureTransforms = env->GetBooleanField(src, hasTextureTransforms);
+    dst.emissiveUV = env->GetIntField(src, emissiveUV);
+    dst.aoUV = env->GetIntField(src, aoUV);
+    dst.normalUV = env->GetIntField(src, normalUV);
+    dst.hasTransmissionTexture = env->GetBooleanField(src, hasTransmissionTexture);
+    dst.transmissionUV = env->GetIntField(src, transmissionUV);
+    dst.hasSheenColorTexture = env->GetBooleanField(src, hasSheenColorTexture);
+    dst.sheenColorUV = env->GetIntField(src, sheenColorUV);
+    dst.hasSheenRoughnessTexture = env->GetBooleanField(src, hasSheenRoughnessTexture);
+    dst.sheenRoughnessUV = env->GetIntField(src, sheenRoughnessUV);
+    dst.hasVolumeThicknessTexture = env->GetBooleanField(src, hasVolumeThicknessTexture);
+    dst.volumeThicknessUV = env->GetIntField(src, volumeThicknessUV);
+    dst.hasSheen = env->GetBooleanField(src, hasSheen);
+    dst.hasIOR = env->GetBooleanField(src, hasIOR);
+}
+
+void MaterialKeyHelper::copy(JNIEnv* env, jobject dst, const MaterialKey& src) {
+    env->SetBooleanField(dst, doubleSided, src.doubleSided);
+    env->SetBooleanField(dst, unlit, src.unlit);
+    env->SetBooleanField(dst, hasVertexColors, src.hasVertexColors);
+    env->SetBooleanField(dst, hasBaseColorTexture, src.hasBaseColorTexture);
+    env->SetBooleanField(dst, hasNormalTexture, src.hasNormalTexture);
+    env->SetBooleanField(dst, hasOcclusionTexture, src.hasOcclusionTexture);
+    env->SetBooleanField(dst, hasEmissiveTexture, src.hasEmissiveTexture);
+    env->SetBooleanField(dst, useSpecularGlossiness, src.useSpecularGlossiness);
+    env->SetIntField(dst, alphaMode, (int) src.alphaMode);
+    env->SetBooleanField(dst, enableDiagnostics, src.enableDiagnostics);
+    env->SetBooleanField(dst, hasMetallicRoughnessTexture, src.hasMetallicRoughnessTexture);
+    env->SetIntField(dst, metallicRoughnessUV, src.metallicRoughnessUV);
+    env->SetIntField(dst, baseColorUV, src.baseColorUV);
+    env->SetBooleanField(dst, hasClearCoatTexture, src.hasClearCoatTexture);
+    env->SetIntField(dst, clearCoatUV, src.clearCoatUV);
+    env->SetBooleanField(dst, hasClearCoatRoughnessTexture, src.hasClearCoatRoughnessTexture);
+    env->SetIntField(dst, clearCoatRoughnessUV, src.clearCoatRoughnessUV);
+    env->SetBooleanField(dst, hasClearCoatNormalTexture, src.hasClearCoatNormalTexture);
+    env->SetIntField(dst, clearCoatNormalUV, src.clearCoatNormalUV);
+    env->SetBooleanField(dst, hasClearCoat, src.hasClearCoat);
+    env->SetBooleanField(dst, hasTransmission, src.hasTransmission);
+    env->SetBooleanField(dst, hasTextureTransforms, src.hasTextureTransforms);
+    env->SetIntField(dst, emissiveUV, src.emissiveUV);
+    env->SetIntField(dst, aoUV, src.aoUV);
+    env->SetIntField(dst, normalUV, src.normalUV);
+    env->SetBooleanField(dst, hasTransmissionTexture, src.hasTransmissionTexture);
+    env->SetIntField(dst, transmissionUV, src.transmissionUV);
+    env->SetBooleanField(dst, hasSheenColorTexture, src.hasSheenColorTexture);
+    env->SetIntField(dst, sheenColorUV, src.sheenColorUV);
+    env->SetBooleanField(dst, hasSheenRoughnessTexture, src.hasSheenRoughnessTexture);
+    env->SetIntField(dst, sheenRoughnessUV, src.sheenRoughnessUV);
+    env->SetBooleanField(dst, hasVolumeThicknessTexture, src.hasVolumeThicknessTexture);
+    env->SetIntField(dst, volumeThicknessUV, src.volumeThicknessUV);
+    env->SetBooleanField(dst, hasSheen, src.hasSheen);
+    env->SetBooleanField(dst, hasIOR, src.hasIOR);
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_gltfio_MaterialProvider_00024MaterialKey_nGlobalInit(JNIEnv* env, jclass) {
+    MaterialKeyHelper::get().init(env);
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_google_android_filament_gltfio_MaterialProvider_00024MaterialKey_nConstrainMaterial(JNIEnv* env, jclass,
+        jobject materialKey, jintArray uvMap) {
+    MaterialKey nativeMaterialKey = {};
+
+    auto& helper = MaterialKeyHelper::get();
+    helper.copy(env, nativeMaterialKey, materialKey);
+
+    UvMap nativeUvMap = {};
+    constrainMaterial(&nativeMaterialKey, &nativeUvMap);
+
+    // Copy the UvMap results from the native array into the JVM array.
+    jint* elements = env->GetIntArrayElements(uvMap, nullptr);
+    if (elements) {
+        const size_t javaSize = env->GetArrayLength(uvMap);
+        for (int i = 0, n = std::min(javaSize, nativeUvMap.size()); i < n; ++i) {
+            elements[i] = nativeUvMap[i];
+        }
+        env->ReleaseIntArrayElements(uvMap, elements, 0);
+    }
+
+    // The config parameter is an in-out parameter so we need to copy the results back to Java.
+    helper.copy(env, materialKey, nativeMaterialKey);
+}

android/gltfio-android/src/main/cpp/MaterialKey.h

@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <jni.h>
+
+#include <gltfio/MaterialProvider.h>
+
+#define JAVA_MATERIAL_KEY "com/google/android/filament/gltfio/MaterialProvider$MaterialKey"
+
+class MaterialKeyHelper {
+public:
+    static MaterialKeyHelper& get();
+
+    void copy(JNIEnv* env, gltfio::MaterialKey& dst, jobject src);
+    void copy(JNIEnv* env, jobject dst, const gltfio::MaterialKey& src);
+
+    void init(JNIEnv* env); // called only from the Java static class constructor
+
+private:
+    jfieldID doubleSided;
+    jfieldID unlit;
+    jfieldID hasVertexColors;
+    jfieldID hasBaseColorTexture;
+    jfieldID hasNormalTexture;
+    jfieldID hasOcclusionTexture;
+    jfieldID hasEmissiveTexture;
+    jfieldID useSpecularGlossiness;
+    jfieldID alphaMode;
+    jfieldID enableDiagnostics;
+    jfieldID hasMetallicRoughnessTexture;
+    jfieldID metallicRoughnessUV;
+    jfieldID baseColorUV;
+    jfieldID hasClearCoatTexture;
+    jfieldID clearCoatUV;
+    jfieldID hasClearCoatRoughnessTexture;
+    jfieldID clearCoatRoughnessUV;
+    jfieldID hasClearCoatNormalTexture;
+    jfieldID clearCoatNormalUV;
+    jfieldID hasClearCoat;
+    jfieldID hasTransmission;
+    jfieldID hasTextureTransforms;
+    jfieldID emissiveUV;
+    jfieldID aoUV;
+    jfieldID normalUV;
+    jfieldID hasTransmissionTexture;
+    jfieldID transmissionUV;
+    jfieldID hasSheenColorTexture;
+    jfieldID sheenColorUV;
+    jfieldID hasSheenRoughnessTexture;
+    jfieldID sheenRoughnessUV;
+    jfieldID hasVolumeThicknessTexture;
+    jfieldID volumeThicknessUV;
+    jfieldID hasSheen;
+    jfieldID hasIOR;
+};

android/gltfio-android/src/main/cpp/ResourceLoader.cpp

@@ -35,10 +35,11 @@ static void destroy(void*, size_t, void *userData) {
 
 extern "C" JNIEXPORT jlong JNICALL
 Java_com_google_android_filament_gltfio_ResourceLoader_nCreateResourceLoader(JNIEnv*, jclass,
-        jlong nativeEngine, jboolean normalizeSkinningWeights, jboolean recomputeBoundingBoxes) {
+        jlong nativeEngine, jboolean normalizeSkinningWeights, jboolean recomputeBoundingBoxes,
+        jboolean ignoreBindTransform) {
     Engine* engine = (Engine*) nativeEngine;
     return (jlong) new ResourceLoader({ engine, {}, (bool) normalizeSkinningWeights,
-            (bool) recomputeBoundingBoxes });
+            (bool) recomputeBoundingBoxes, (bool) ignoreBindTransform});
 }
 
 extern "C" JNIEXPORT void JNICALL
@@ -70,6 +71,13 @@ Java_com_google_android_filament_gltfio_ResourceLoader_nHasResourceData(JNIEnv*
     return status;
 }
 
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_gltfio_ResourceLoader_nEvictResourceData(JNIEnv*, jclass,
+        jlong nativeLoader) {
+    ResourceLoader* loader = (ResourceLoader*) nativeLoader;
+    loader->evictResourceData();
+}
+
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_gltfio_ResourceLoader_nLoadResources(JNIEnv*, jclass,
         jlong nativeLoader, jlong nativeAsset) {
@@ -99,3 +107,10 @@ Java_com_google_android_filament_gltfio_ResourceLoader_nAsyncUpdateLoad(JNIEnv*,
     ResourceLoader* loader = (ResourceLoader*) nativeLoader;
     loader->asyncUpdateLoad();
 }
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_gltfio_ResourceLoader_nAsyncCancelLoad(JNIEnv*, jclass,
+        jlong nativeLoader) {
+    ResourceLoader* loader = (ResourceLoader*) nativeLoader;
+    loader->asyncCancelLoad();
+}

android/gltfio-android/src/main/cpp/UbershaderLoader.cpp

@@ -0,0 +1,102 @@
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <jni.h>
+
+#include <gltfio/MaterialProvider.h>
+
+#include <utils/debug.h>
+
+#include "MaterialKey.h"
+
+using namespace filament;
+using namespace gltfio;
+
+extern "C" JNIEXPORT jlong JNICALL
+Java_com_google_android_filament_gltfio_UbershaderLoader_nCreateUbershaderLoader(JNIEnv*, jclass,
+        jlong nativeEngine) {
+    Engine* engine = (Engine*) nativeEngine;
+    return (jlong) createUbershaderLoader(engine);
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_gltfio_UbershaderLoader_nDestroyUbershaderLoader(JNIEnv*, jclass,
+        jlong nativeProvider) {
+    auto provider = (MaterialProvider*) nativeProvider;
+    delete provider;
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_gltfio_UbershaderLoader_nDestroyMaterials(JNIEnv*, jclass,
+        jlong nativeProvider) {
+    auto provider = (MaterialProvider*) nativeProvider;
+    provider->destroyMaterials();
+}
+
+extern "C" JNIEXPORT long JNICALL
+Java_com_google_android_filament_gltfio_UbershaderLoader_nCreateMaterialInstance(JNIEnv* env, jclass,
+        jlong nativeProvider, jobject materialKey, jintArray uvmap, jstring label) {
+    MaterialKey nativeKey = {};
+
+    auto& helper = MaterialKeyHelper::get();
+    helper.copy(env, nativeKey, materialKey);
+
+    const char* nativeLabel = label ? env->GetStringUTFChars(label, nullptr) : nullptr;
+    UvMap nativeUvMap = {};
+    auto provider = (MaterialProvider*) nativeProvider;
+    MaterialInstance* instance = provider->createMaterialInstance(&nativeKey, &nativeUvMap, nativeLabel);
+
+    // Copy the UvMap results from the native array into the JVM array.
+    jint* elements = env->GetIntArrayElements(uvmap, nullptr);
+    if (elements) {
+        const size_t javaSize = env->GetArrayLength(uvmap);
+        for (int i = 0, n = std::min(javaSize, nativeUvMap.size()); i < n; ++i) {
+            elements[i] = nativeUvMap[i];
+        }
+        env->ReleaseIntArrayElements(uvmap, elements, 0);
+    }
+
+    // The config parameter is an in-out parameter so we need to copy the results back to Java.
+    helper.copy(env, materialKey, nativeKey);
+
+    if (label) {
+        env->ReleaseStringUTFChars(label, nativeLabel);
+    }
+
+    return (long) instance;
+}
+
+extern "C" JNIEXPORT int JNICALL
+Java_com_google_android_filament_gltfio_UbershaderLoader_nGetMaterialCount(JNIEnv*, jclass,
+        jlong nativeProvider) {
+    auto provider = (MaterialProvider*) nativeProvider;
+    return provider->getMaterialsCount();
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_gltfio_UbershaderLoader_nGetMaterials(JNIEnv* env, jclass,
+        jlong nativeProvider, jlongArray result) {
+    auto provider = (MaterialProvider *) nativeProvider;
+    auto materials = provider->getMaterials();
+    jlong *resultElements = env->GetLongArrayElements(result, nullptr);
+    if (resultElements) {
+        const size_t javaSize = env->GetArrayLength(result);
+        for (int i = 0, n = std::min(javaSize, provider->getMaterialsCount()); i < n; ++i) {
+            resultElements[i] = (jlong) materials[i];
+        }
+        env->ReleaseLongArrayElements(result, resultElements, JNI_ABORT);
+    }
+}

android/gltfio-android/src/main/java/com/google/android/filament/gltfio/AssetLoader.java

@@ -45,7 +45,7 @@ import java.nio.Buffer;
  *
  *     ...
  *
- *     assetLoader = AssetLoader(engine, MaterialProvider(engine), EntityManager.get())
+ *     assetLoader = AssetLoader(engine, UbershaderLoader(engine), EntityManager.get())
  *
  *     filamentAsset = assets.open("models/lucy.gltf").use { input ->
  *         val bytes = ByteArray(input.available())
@@ -78,34 +78,36 @@ import java.nio.Buffer;
 public class AssetLoader {
     private long mNativeObject;
     private Engine mEngine;
+    private MaterialProvider mMaterialCache;
 
     /**
-     * Constructs an <code>AssetLoader </code>that can be used to create and destroy instances of
+     * Constructs an <code>AssetLoader</code> that can be used to create and destroy instances of
      * {@link FilamentAsset}.
      *
      * @param engine the engine that the loader should pass to builder objects
-     * @param generator specifies if materials should be generated or loaded from a pre-built set
+     * @param provider an object that provides Filament materials corresponding to glTF materials
      * @param entities the EntityManager that should be used to create entities
      */
-    public AssetLoader(@NonNull Engine engine, @NonNull MaterialProvider generator,
+    public AssetLoader(@NonNull Engine engine, @NonNull MaterialProvider provider,
             @NonNull EntityManager entities) {
 
         long nativeEngine = engine.getNativeObject();
-        long nativeMaterials = generator.getNativeObject();
         long nativeEntities = entities.getNativeObject();
-        mNativeObject = nCreateAssetLoader(nativeEngine, nativeMaterials, nativeEntities);
+        mNativeObject = nCreateAssetLoader(nativeEngine, provider, nativeEntities);
 
         if (mNativeObject == 0) {
             throw new IllegalStateException("Unable to parse glTF asset.");
         }
 
         mEngine = engine;
+        mMaterialCache = provider;
     }
 
     /**
      * Frees all memory consumed by the native <code>AssetLoader</code> and its material cache.
      */
     public void destroy() {
+        mMaterialCache.destroyMaterials();
         nDestroyAssetLoader(mNativeObject);
         mNativeObject = 0;
     }
@@ -146,10 +148,37 @@ public class AssetLoader {
         if (nativeAsset == 0) {
             return null;
         }
+        FilamentAsset asset = new FilamentAsset(mEngine, nativeAsset);
         for (int i = 0; i < nativeInstances.length; i++) {
-            instances[i] = new FilamentInstance(nativeInstances[i]);
+            instances[i] = new FilamentInstance(asset, nativeInstances[i]);
         }
-        return new FilamentAsset(mEngine, nativeAsset);
+        return asset;
+    }
+
+    /**
+     * Adds a new instance to an instanced asset.
+     *
+     * Use this with caution. It is more efficient to pre-allocate a max number of instances, and
+     * gradually add them to the scene as needed. Instances can also be "recycled" by removing and
+     * re-adding them to the scene.
+     *
+     * NOTE: destroyInstance() does not exist because gltfio favors flat arrays for storage of
+     * entity lists and instance lists, which would be slow to shift. We also wish to discourage
+     * create/destroy churn, as noted above.
+     *
+     * This cannot be called after FilamentAsset#releaseSourceData().
+     * This cannot be called on a non-instanced asset.
+     * Animation is not supported in new instances.
+     * See also AssetLoader#createInstancedAsset().
+     */
+    @Nullable
+    @SuppressWarnings("unused")
+    public FilamentInstance createInstance(@NonNull FilamentAsset asset) {
+        long nativeInstance = nCreateInstance(mNativeObject, asset.getNativeObject());
+        if (nativeInstance == 0) {
+            return null;
+        }
+        return new FilamentInstance(asset, nativeInstance);
     }
 
     /**
@@ -168,13 +197,14 @@ public class AssetLoader {
         asset.clearNativeObject();
     }
 
-    private static native long nCreateAssetLoader(long nativeEngine, long nativeGenerator,
+    private static native long nCreateAssetLoader(long nativeEngine, Object provider,
             long nativeEntities);
     private static native void nDestroyAssetLoader(long nativeLoader);
     private static native long nCreateAssetFromBinary(long nativeLoader, Buffer buffer, int remaining);
     private static native long nCreateAssetFromJson(long nativeLoader, Buffer buffer, int remaining);
     private static native long nCreateInstancedAsset(long nativeLoader, Buffer buffer, int remaining,
             long[] nativeInstances);
+    private static native long nCreateInstance(long nativeLoader, long nativeAsset);
     private static native void nEnableDiagnostics(long nativeLoader, boolean enable);
     private static native void nDestroyAsset(long nativeLoader, long nativeAsset);
 }

android/gltfio-android/src/main/java/com/google/android/filament/gltfio/FilamentAsset.java

@@ -186,6 +186,16 @@ public class FilamentAsset {
         return nGetName(getNativeObject(), entity);
     }
 
+    /**
+     * Gets the glTF extras string for the asset or a specific node.
+     *
+     * @param entity the entity corresponding to the glTF node, or 0 to get the asset-level string.
+     * @return the requested extras string, or null if it does not exist.
+     */
+    public @Nullable String getExtras(@Entity int entity) {
+        return nGetExtras(mNativeObject, entity);
+    }
+
     /**
      * Creates or retrieves the <code>Animator</code> interface for this asset.
      *
@@ -197,7 +207,11 @@ public class FilamentAsset {
         if (mAnimator != null) {
             return mAnimator;
         }
-        mAnimator = new Animator(nGetAnimator(getNativeObject()));
+        long nativeAnimator = nGetAnimator(getNativeObject());
+        if (nativeAnimator == 0) {
+            throw new IllegalStateException("Unable to create animator");
+        }
+        mAnimator = new Animator(nativeAnimator);
         return mAnimator;
     }
 
@@ -215,6 +229,7 @@ public class FilamentAsset {
      *
      * This should only be called after ResourceLoader#loadResources().
      * If using Animator, this should be called after getAnimator().
+     * If this is an instanced asset, this prevents creation of new instances.
      */
     public void releaseSourceData() {
         nReleaseSourceData(mNativeObject);
@@ -247,6 +262,7 @@ public class FilamentAsset {
 
     private static native void nGetBoundingBox(long nativeAsset, float[] box);
     private static native String nGetName(long nativeAsset, int entity);
+    private static native String nGetExtras(long nativeAsset, int entity);
     private static native long nGetAnimator(long nativeAsset);
     private static native int nGetResourceUriCount(long nativeAsset);
     private static native void nGetResourceUris(long nativeAsset, String[] result);

android/gltfio-android/src/main/java/com/google/android/filament/gltfio/FilamentInstance.java

@@ -28,10 +28,12 @@ import com.google.android.filament.Entity;
  * @see AssetLoader
  */
 public class FilamentInstance {
+    private FilamentAsset mAsset;
     private long mNativeObject;
     private Animator mAnimator;
 
-    FilamentInstance(long nativeObject) {
+    FilamentInstance(FilamentAsset asset, long nativeObject) {
+        mAsset = asset;
         mNativeObject = nativeObject;
         mAnimator = null;
     }
@@ -46,6 +48,11 @@ public class FilamentInstance {
         mNativeObject = 0;
     }
 
+    @SuppressWarnings("unused")
+    public @NonNull FilamentAsset getAsset() {
+        return mAsset;
+    }
+
     /**
      * Gets the transform root for the asset, which has no matching glTF node.
      */