Merge branch 'rc/1.9.21' into release

This fixes a recent regression that would occur when a RenderTarget
does not have a depth attachment.

.dir-locals.el

@@ -1,7 +0,0 @@
-;;; Directory Local Variables            -*- no-byte-compile: t -*-
-;;; For more information see (info "(emacs) Directory Variables")
-
-((c++-mode . ((c-file-style . "filament")
-              (apheleia-inhibit . t)))
- (c-mode . ((c-file-style . "filament")
-            (apheleia-inhibit . t))))

.editorconfig

@@ -1,11 +0,0 @@
-root = true
-
-[*]
-end_of_line = lf
-insert_final_newline = true
-charset = utf-8
-
-[*.{c,cpp,h,inc,kt,java,js,md}]
-indent_style = space
-indent_size = 4
-max_line_length = 100

.github/ISSUE_TEMPLATE/bug_report.md

@@ -4,8 +4,6 @@ about: Create a report to help us improve
 
 ---
 
-⚠️ **Issues not using this template will be systematically closed.**
-
 **Describe the bug**
 A clear and concise description of what the bug is.
 
@@ -19,10 +17,6 @@ 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 **full** logs from your console here. Please *do not*
-use screenshots of logs, copy them as text, use gist or attach an *uncompressed* file.
-
 **Desktop (please complete the following information):**
  - OS: [e.g. iOS]
  - GPU: [e.g. NVIDIA GTX 1080]

.github/actions/android-continuous/action.yml

@@ -1,17 +0,0 @@
-name: 'Android Continuous'
-inputs:
-  build-abi:
-    description: 'The target platform ABI'
-    required: true
-    default: 'armeabi-v7a'
-runs:
-  using: "composite"
-  steps:
-    - uses: actions/setup-java@v3
-      with:
-        distribution: 'temurin'
-        java-version: '17'
-    - name: Run build script
-      run: |
-        cd build/android && printf "y" | ./build.sh continuous ${{ inputs.build-abi }}
-      shell: bash

.github/actions/ubuntu-apt-add-src/action.yml

@@ -1,9 +0,0 @@
-name: 'ubuntu apt add deb-src'
-runs:
-  using: "composite"
-  steps:
-    - name: "ubuntu apt add deb-src"
-      run: |
-          echo "deb-src http://archive.ubuntu.com/ubuntu jammy main restricted universe" | sudo tee /etc/apt/sources.list.d/my.list
-          sudo apt-get update
-      shell: bash

.github/actions/verify-release-notes/Dockerfile

@@ -1,10 +0,0 @@
-FROM python:3.10.4
-
-RUN pip3 install pygithub==1.55
-
-ENV PYTHONUNBUFFERED=1
-
-COPY verify_release_notes.py /verify_release_notes.py
-
-RUN chmod +x /verify_release_notes.py
-ENTRYPOINT [ "/verify_release_notes.py" ]

.github/actions/verify-release-notes/action.yml

@@ -1,35 +0,0 @@
-name: 'Verify Release Notes'
-description: 'Verifies that a RELEASE_NOTES file has been modified'
-inputs:
-  repo-token:
-    description: 'The GitHub token'
-    required: true
-  pull-request-number:
-    description: 'The Pull Request number'
-    required: true
-  bypass-label-name:
-    description: 'The Label used to bypass this check'
-    required: false
-    default: 'internal'
-  release-notes-file:
-    description: 'The path to the RELEASE_NOTES file'
-    required: false
-    default: 'RELEASE_NOTES.md'
-  pull-request-repo-full-name:
-    description: 'The full name of the Pull Request repo'
-    required: false
-    default: ${{ github.event.pull_request.head.repo.full_name }}
-  pull-request-head-ref:
-    description: 'The HEAD ref of the Pull Request'
-    required: false
-    default: ${{ github.event.pull_request.head.ref }}
-runs:
-  using: 'docker'
-  image: 'Dockerfile'
-  args:
-    - ${{ inputs.repo-token }}
-    - ${{ inputs.pull-request-number }}
-    - ${{ inputs.bypass-label-name }}
-    - ${{ inputs.release-notes-file }}
-    - ${{ inputs.pull-request-repo-full-name }}
-    - ${{ inputs.pull-request-head-ref }}

.github/actions/verify-release-notes/verify_release_notes.py

@@ -1,100 +0,0 @@
-#!/usr/bin/env python3
-
-# Copyright (C) 2022 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.
-
-from github import Github
-import sys, os
-
-def print_usage():
-    print('Verify that a GitHub pull request modifies a RELEASE_NOTES file')
-    print()
-    print('Usage:')
-    print('  verify_release_notes.py [arguments]')
-    print()
-    print('Arguments:')
-    print('1. github token')
-    print('2. pull request number')
-    print('3. bypass label name')
-    print('4. release notes file path')
-    print('5. pull request repo full name')
-    print('6. pull request head ref')
-    print()
-    print('The GITHUB_REPOSITORY environment variable must be set (e.g., google/filament).')
-
-def leave_single_comment(pull_request, comment_body):
-    """ Leaves a comment on a PR once, without leaving a duplicate comment. """
-    # To avoid spamming the PR author, we'll use this comment tag (which will render invisibly on
-    # GitHub) to check if we've already left a comment on this PR.
-    COMMENT_TAG = '<!-- verify_release_notes -->\n'
-    comments = pull_request.get_issue_comments()
-    for comment in comments:
-        if comment.body.find(COMMENT_TAG) != -1:
-            return
-    # The GitHub token may not have WRITE permissions to leave a comment (for example, for 3P
-    # contributors). In that case, we simply won't leave a comment.
-    try:
-        pull_request.create_issue_comment(f'{COMMENT_TAG}{comment_body}')
-    except:
-        print("Unable to leave comment. Continuing.")
-
-# The first argument is the path to this script.
-if len(sys.argv) != 7:
-    print_usage()
-    sys.exit(1)
-
-authentication_token = sys.argv[1]
-pull_number = sys.argv[2]
-bypass_label_name = sys.argv[3]
-release_notes_file = sys.argv[4]
-pr_repo_full_name = sys.argv[5]
-pr_head_ref = sys.argv[6]
-
-g = Github(authentication_token)
-
-repo_name = os.environ.get('GITHUB_REPOSITORY')
-if repo_name is None:
-    print("The GITHUB_REPOSITORY environment variable must be set.")
-    sys.exit(1)
-
-repo = g.get_repo(repo_name)
-
-pull_request = repo.get_pull(int(pull_number))
-
-# First check if the PR has the "bypass" label. This label is used for PRs that don't need to update
-# RELEASE_NOTES. If so, we can exit immediately.
-labels = [l.name for l in pull_request.labels]
-if bypass_label_name in labels:
-    print(f"PR number {pull_number} in repo {repo_name} contains the '{bypass_label_name}' label.")
-    print("Exiting with success.")
-    sys.exit(0)
-
-# Next, check if the release notes file (RELEASE_NOTES.md or similar) has been modified.
-files = pull_request.get_files()
-for file in files:
-    if file.filename == release_notes_file:
-        print(f"PR number {pull_number} in repo {repo_name} modifies '{release_notes_file}'.")
-        print("Exiting with success.")
-        sys.exit(0)
-
-# At this point, we issue a warning to the PR author to remember to modify the release notes, and
-# exit with failure.
-edit_url = f"https://github.com/{pr_repo_full_name}/edit/{pr_head_ref}/{release_notes_file}"
-comment = (f"Please add a release note line to [{release_notes_file}]({edit_url}). "
-    f"If this PR does not warrant a release note, add the '{bypass_label_name}' label "
-    f"to this PR.")
-print(comment)
-leave_single_comment(pull_request, comment)
-
-sys.exit(1)

.github/workflows/android-continuous.yml

@@ -10,13 +10,34 @@ on:
 jobs:
   build-android:
     name: build-android
-    # We intentially use a larger runner here to enable larger disk space
-    # (standard linux runner will fail on disk space and faster build time).
-    runs-on: ubuntu-22.04-32core
+    runs-on: macos-latest
 
     steps:
-      - uses: actions/checkout@v4.1.6
-      - name: Run Android Continuous
-        uses: ./.github/actions/android-continuous
+      - uses: actions/checkout@v2.0.0
+      - name: Run build script
+        run: |
+          cd build/android && printf "y" | ./build.sh continuous
+      - uses: actions/upload-artifact@v1.0.0
         with:
-          build-abi: armeabi-v7a,arm64-v8a,x86_64
+          name: filament-android
+          path: out/filament-android-release.aar
+      - uses: actions/upload-artifact@v1.0.0
+        with:
+          name: filamat-android-full
+          path: out/filamat-android-release.aar
+      - uses: actions/upload-artifact@v1.0.0
+        with:
+          name: filamat-android-lite
+          path: out/filamat-android-lite-release.aar
+      - uses: actions/upload-artifact@v1.0.0
+        with:
+          name: gltfio-android-release
+          path: out/gltfio-android-release.aar
+      - uses: actions/upload-artifact@v1.0.0
+        with:
+          name: gltfio-android-lite-release
+          path: out/gltfio-android-lite-release.aar
+      - uses: actions/upload-artifact@v1.0.0
+        with:
+          name: filament-utils-android-release
+          path: out/filament-utils-android-release.aar

.github/workflows/cocopods-deploy.yml

@@ -1,30 +0,0 @@
-name: CocoaPods Deploy
-
-# This must be run after the iOS release job has finished, and the iOS release
-# asset has been uploaded to Github.
-on:
-  workflow_dispatch:
-    inputs:
-      release_tag:
-        description: 'Release tag to deploy (e.g., v1.42.2)'
-        required: true
-        default: 'v1.42.2'
-
-jobs:
-  cocoapods-deploy:
-    name: cocoapods-deploy
-    runs-on: macos-14
-    steps:
-      - name: Check out iOS/CocoaPods directory
-        uses: Bhacaz/checkout-files@49fc3050859046bf4f4873678d46099985640e89
-        with:
-          files: ios/CocoaPods
-          token: ${{ secrets.GITHUB_TOKEN }}
-          branch: ${{ github.event.inputs.release_tag }}
-      - name: Move podspec to root
-        run: mv ios/CocoaPods/*.podspec .
-      - name: Install CocoaPods
-        run: gem install cocoapods
-      - uses: michaelhenry/deploy-to-cocoapods-github-action@745686ab065f90596e0d5cfcf97bb2416d94262e
-        env:
-          COCOAPODS_TRUNK_TOKEN: ${{ secrets.COCOAPODS_TRUNK_TOKEN }}

.github/workflows/ios-continuous.yml

@@ -10,14 +10,14 @@ on:
 jobs:
   build-ios:
     name: build-ios
-    runs-on: macos-14-xlarge
+    runs-on: macos-latest
 
     steps:
-      - uses: actions/checkout@v4.1.6
+      - uses: actions/checkout@v2.0.0
       - name: Run build script
         run: |
           cd build/ios && printf "y" | ./build.sh continuous
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v1.0.0
         with:
           name: filament-ios
           path: out/filament-release-ios.tgz

.github/workflows/linux-continuous.yml

@@ -10,14 +10,14 @@ on:
 jobs:
   build-linux:
     name: build-linux
-    runs-on: ubuntu-22.04-16core
+    runs-on: ubuntu-18.04
 
     steps:
-      - uses: actions/checkout@v4.1.6
+      - uses: actions/checkout@v2.0.0
       - name: Run build script
         run: |
           cd build/linux && printf "y" | ./build.sh continuous
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v1.0.0
         with:
           name: filament-linux
           path: out/filament-release-linux.tgz

.github/workflows/mac-continuous.yml

@@ -10,17 +10,14 @@ on:
 jobs:
   build-mac:
     name: build-mac
-    runs-on: macos-14-xlarge
+    runs-on: macos-latest
 
     steps:
-      - uses: actions/checkout@v4.1.6
+      - uses: actions/checkout@v2.0.0
       - name: Run build script
         run: |
           cd build/mac && printf "y" | ./build.sh continuous
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v1.0.0
         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/npm-deploy.yml

@@ -1,33 +0,0 @@
-name: Npm Deploy
-
-on:
-  workflow_dispatch:
-    inputs:
-      release_tag:
-        description: 'Release tag to deploy (e.g., v1.42.2)'
-        required: true
-        default: 'v1.42.2'
-
-jobs:
-  npm-deploy:
-    name: npm-deploy
-    runs-on: macos-14
-    steps:
-      - uses: actions/checkout@v4.1.6
-        with:
-          ref: ${{ github.event.inputs.release_tag }}
-      # Setup .npmrc file to publish to npm
-      - uses: actions/setup-node@v3
-        with:
-          node-version: '18.x'
-          registry-url: 'https://registry.npmjs.org'
-      - name: Run build script
-        run: |
-          cd build/web && printf "y" | ./build.sh release
-      - name: Deploy to npm
-        run: |
-          cd out/cmake-webgl-release/web/filament-js
-          npm publish
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
-

.github/workflows/presubmit.yml

@@ -15,10 +15,10 @@ jobs:
 
     strategy:
       matrix:
-        os: [macos-14-xlarge, ubuntu-22.04-16core]
+        os: [macos-latest, ubuntu-18.04]
 
     steps:
-      - uses: actions/checkout@v4.1.6
+      - uses: actions/checkout@v2.0.0
       - name: Run build script
         run: |
           WORKFLOW_OS=`echo \`uname\` | sed "s/Darwin/mac/" | tr [:upper:] [:lower:]`
@@ -29,10 +29,10 @@ jobs:
 
   build-windows:
     name: build-windows
-    runs-on: win-2019-16core
+    runs-on: windows-latest
 
     steps:
-      - uses: actions/checkout@v4.1.6
+      - uses: actions/checkout@v2.0.0
       - name: Run build script
         run: |
           build\windows\build-github.bat presubmit
@@ -40,26 +40,20 @@ jobs:
 
   build-android:
     name: build-android
-    runs-on: ubuntu-22.04-16core
+    runs-on: macos-latest
 
     steps:
-      - uses: actions/checkout@v4.1.6
-      - uses: actions/setup-java@v3
-        with:
-          distribution: 'temurin'
-          java-version: '17'
+      - uses: actions/checkout@v2.0.0
       - name: Run build script
-        # Only build 1 64 bit target during presubmit to cut down build times during presubmit
-        # Continuous builds will build everything
         run: |
-          cd build/android && printf "y" | ./build.sh presubmit arm64-v8a
+          cd build/android && printf "y" | ./build.sh presubmit
 
   build-ios:
     name: build-iOS
-    runs-on: macos-14-xlarge
+    runs-on: macos-latest
 
     steps:
-      - uses: actions/checkout@v4.1.6
+      - uses: actions/checkout@v2.0.0
       - name: Run build script
         run: |
           cd build/ios && printf "y" | ./build.sh presubmit
@@ -69,25 +63,10 @@ jobs:
 
   build-web:
     name: build-web
-    runs-on: ubuntu-22.04-16core
+    runs-on: macos-latest
 
     steps:
-      - uses: actions/checkout@v4.1.6
+      - uses: actions/checkout@v2.0.0
       - name: Run build script
         run: |
           cd build/web && printf "y" | ./build.sh presubmit
-
-  test-renderdiff:
-    name: test-renderdiff
-    runs-on: ubuntu-22.04-32core
-
-    steps:
-      - uses: actions/checkout@v4.1.6
-      - uses: ./.github/actions/ubuntu-apt-add-src
-      - name: Run script
-        run: |
-          source ./build/linux/ci-common.sh && bash test/renderdiff_tests.sh
-      - uses: actions/upload-artifact@v4
-        with:
-          name: presubmit-renderdiff-result
-          path: ./out/renderdiff_tests

.github/workflows/release.yml

@@ -1,25 +1,14 @@
 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 workflow_dispatch event is triggered from the GitHub web UI. 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 repository_dispatch API event is sent. This triggers a build for only the platform specified in the dispatch event.
 
 env:
-  RELEASE_TAG: ${{ github.event.inputs.release_tag }}
+  RELEASE_TAG: ${{ github.event.client_payload.release_tag }}
 
 on:
-  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'
+  repository_dispatch:
   release:
     types: [created]
 
@@ -27,11 +16,11 @@ jobs:
   build-desktop:
     name: build-desktop
     runs-on: ${{ matrix.os }}
-    if: github.event_name == 'release' || github.event.inputs.platform == 'desktop'
+    if: github.event_name == 'release' || github.event.client_payload.platform == 'desktop'
 
     strategy:
       matrix:
-        os: [macos-14-xlarge, ubuntu-22.04-32core]
+        os: [macos-latest, ubuntu-18.04]
 
     steps:
       - name: Decide Git ref
@@ -39,34 +28,30 @@ jobs:
         run: |
           REF=${RELEASE_TAG:-${GITHUB_REF}}
           TAG=${REF##*/}
-          echo "ref=${REF}" >> $GITHUB_OUTPUT
-          echo "tag=${TAG}" >> $GITHUB_OUTPUT
-      - uses: actions/checkout@v4.1.6
+          echo ::set-output name=ref::${REF}
+          echo ::set-output name=tag::${TAG}
+      - uses: actions/checkout@v2.0.0
         with:
           ref: ${{ steps.git_ref.outputs.ref }}
       - name: Run build script
-        env:
-          TAG: ${{ steps.git_ref.outputs.tag }}
         run: |
           WORKFLOW_OS=`echo \`uname\` | sed "s/Darwin/mac/" | tr [:upper:] [:lower:]`
           cd build/$WORKFLOW_OS && printf "y" | ./build.sh release
-          cd ../..
+      - name: Upload release assets
+        run: |
+          pip3 install setuptools
+          pip3 install PyGithub
           if [ -f out/filament-release-darwin.tgz ]; then mv out/filament-release-darwin.tgz out/filament-${TAG}-mac.tgz; fi;
           if [ -f out/filament-release-linux.tgz ]; then mv out/filament-release-linux.tgz out/filament-${TAG}-linux.tgz; fi;
-      - uses: actions/github-script@v6
+          python3 build/common/upload-assets.py ${TAG} out/*.tgz
         env:
           TAG: ${{ steps.git_ref.outputs.tag }}
-        with:
-          script: |
-            const upload = require('./build/common/upload-release-assets');
-            const { TAG } = process.env;
-            const globber = await glob.create('out/*.tgz');
-            await upload({ github, context }, await globber.glob(), TAG);
+          GITHUB_API_KEY: ${{ secrets.GITHUB_API_KEY }}
 
   build-web:
     name: build-web
-    runs-on: ubuntu-22.04-16core
-    if: github.event_name == 'release' || github.event.inputs.platform == 'web'
+    runs-on: macos-latest
+    if: github.event_name == 'release' || github.event.client_payload.platform == 'web'
 
     steps:
       - name: Decide Git ref
@@ -74,32 +59,28 @@ jobs:
         run: |
           REF=${RELEASE_TAG:-${GITHUB_REF}}
           TAG=${REF##*/}
-          echo "ref=${REF}" >> $GITHUB_OUTPUT
-          echo "tag=${TAG}" >> $GITHUB_OUTPUT
-      - uses: actions/checkout@v4.1.6
+          echo ::set-output name=ref::${REF}
+          echo ::set-output name=tag::${TAG}
+      - uses: actions/checkout@v2.0.0
         with:
           ref: ${{ steps.git_ref.outputs.ref }}
       - name: Run build script
-        env:
-          TAG: ${{ steps.git_ref.outputs.tag }}
         run: |
           cd build/web && printf "y" | ./build.sh release
-          cd ../..
+      - name: Upload release assets
+        run: |
+          pip3 install setuptools
+          pip3 install PyGithub
           mv out/filament-release-web.tgz out/filament-${TAG}-web.tgz
-      - uses: actions/github-script@v6
+          python3 build/common/upload-assets.py ${TAG} out/*.tgz
         env:
           TAG: ${{ steps.git_ref.outputs.tag }}
-        with:
-          script: |
-            const upload = require('./build/common/upload-release-assets');
-            const { TAG } = process.env;
-            const globber = await glob.create('out/*.tgz');
-            await upload({ github, context }, await globber.glob(), TAG);
+          GITHUB_API_KEY: ${{ secrets.GITHUB_API_KEY }}
 
   build-android:
     name: build-android
-    runs-on: ubuntu-22.04-16core
-    if: github.event_name == 'release' || github.event.inputs.platform == 'android'
+    runs-on: macos-latest
+    if: github.event_name == 'release' || github.event.client_payload.platform == 'android'
 
     steps:
       - name: Decide Git ref
@@ -107,53 +88,34 @@ jobs:
         run: |
           REF=${RELEASE_TAG:-${GITHUB_REF}}
           TAG=${REF##*/}
-          echo "ref=${REF}" >> $GITHUB_OUTPUT
-          echo "tag=${TAG}" >> $GITHUB_OUTPUT
-      - uses: actions/checkout@v4.1.6
+          echo ::set-output name=ref::${REF}
+          echo ::set-output name=tag::${TAG}
+      - uses: actions/checkout@v2.0.0
         with:
           ref: ${{ steps.git_ref.outputs.ref }}
-      - uses: actions/setup-java@v3
-        with:
-          distribution: 'temurin'
-          java-version: '17'
       - name: Run build script
-        env:
-          TAG: ${{ steps.git_ref.outputs.tag }}
         run: |
-          cd build/android && printf "y" | ./build.sh release armeabi-v7a,arm64-v8a,x86,x86_64
-          cd ../..
+          cd build/android && printf "y" | ./build.sh release
+      - name: Upload release assets
+        run: |
+          pip3 install setuptools
+          pip3 install PyGithub
           mv out/filament-android-release.aar out/filament-${TAG}-android.aar
           mv out/filamat-android-release.aar out/filamat-${TAG}-android.aar
+          mv out/filamat-android-lite-release.aar out/filamat-${TAG}-lite-android.aar
           mv out/gltfio-android-release.aar out/gltfio-${TAG}-android.aar
+          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
-      - name: Sign sample-gltf-viewer
-        run: |
-          echo "${APK_KEYSTORE_BASE64}" > filament.jks.base64
-          base64 --decode -i 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}"
+          mv out/filament-utils-android-lite-release.aar out/filament-utils-${TAG}-lite-android.aar
+          python3 build/common/upload-assets.py ${TAG} out/*.aar
         env:
           TAG: ${{ steps.git_ref.outputs.tag }}
-          APK_KEYSTORE_BASE64: ${{ secrets.APK_KEYSTORE_BASE64 }}
-          APK_KEYSTORE_PASS: ${{ secrets.APK_KEYSTORE_PASS }}
-      - uses: actions/github-script@v6
-        env:
-          TAG: ${{ steps.git_ref.outputs.tag }}
-        with:
-          script: |
-            const upload = require('./build/common/upload-release-assets');
-            const { TAG } = process.env;
-            const globber = await glob.create(['out/*.aar', 'out/*.apk'].join('\n'));
-            await upload({ github, context }, await globber.glob(), TAG);
+          GITHUB_API_KEY: ${{ secrets.GITHUB_API_KEY }}
 
   build-ios:
     name: build-ios
-    runs-on: macos-14-xlarge
-    if: github.event_name == 'release' || github.event.inputs.platform == 'ios'
+    runs-on: macos-latest
+    if: github.event_name == 'release' || github.event.client_payload.platform == 'ios'
 
     steps:
       - name: Decide Git ref
@@ -161,32 +123,28 @@ jobs:
         run: |
           REF=${RELEASE_TAG:-${GITHUB_REF}}
           TAG=${REF##*/}
-          echo "ref=${REF}" >> $GITHUB_OUTPUT
-          echo "tag=${TAG}" >> $GITHUB_OUTPUT
-      - uses: actions/checkout@v4.1.6
+          echo ::set-output name=ref::${REF}
+          echo ::set-output name=tag::${TAG}
+      - uses: actions/checkout@v2.0.0
         with:
           ref: ${{ steps.git_ref.outputs.ref }}
       - name: Run build script
-        env:
-          TAG: ${{ steps.git_ref.outputs.tag }}
         run: |
           cd build/ios && printf "y" | ./build.sh release
-          cd ../..
+      - name: Upload release assets
+        run: |
+          pip3 install setuptools
+          pip3 install PyGithub
           mv out/filament-release-ios.tgz out/filament-${TAG}-ios.tgz
-      - uses: actions/github-script@v6
+          python3 build/common/upload-assets.py ${TAG} out/*.tgz
         env:
           TAG: ${{ steps.git_ref.outputs.tag }}
-        with:
-          script: |
-            const upload = require('./build/common/upload-release-assets');
-            const { TAG } = process.env;
-            const globber = await glob.create('out/*.tgz');
-            await upload({ github, context }, await globber.glob(), TAG);
+          GITHUB_API_KEY: ${{ secrets.GITHUB_API_KEY }}
 
   build-windows:
     name: build-windows
-    runs-on: windows-2019-32core
-    if: github.event_name == 'release' || github.event.inputs.platform == 'windows'
+    runs-on: windows-latest
+    if: github.event_name == 'release' || github.event.client_payload.platform == 'windows'
 
     steps:
       - name: Decide Git ref
@@ -194,26 +152,22 @@ jobs:
         run: |
           REF=${RELEASE_TAG:-${GITHUB_REF}}
           TAG=${REF##*/}
-          echo "ref=${REF}" >> $GITHUB_OUTPUT
-          echo "tag=${TAG}" >> $GITHUB_OUTPUT
+          echo ::set-output name=ref::${REF}
+          echo ::set-output name=tag::${TAG}
         shell: bash
-      - uses: actions/checkout@v4.1.6
+      - uses: actions/checkout@v2.0.0
         with:
           ref: ${{ steps.git_ref.outputs.ref }}
       - name: Run build script
-        env:
-          TAG: ${{ steps.git_ref.outputs.tag }}
         run: |
           build\windows\build-github.bat release
-          echo on
-          move out\filament-windows.tgz out\filament-%TAG%-windows.tgz
         shell: cmd
-      - uses: actions/github-script@v6
+      - name: Upload release assets
+        run: |
+          pip3 install PyGithub
+          mv out/filament-windows.tgz out/filament-${TAG}-windows.tgz
+          python build/common/upload-assets.py ${TAG} out/*.tgz
+        shell: bash
         env:
           TAG: ${{ steps.git_ref.outputs.tag }}
-        with:
-          script: |
-            const upload = require('./build/common/upload-release-assets');
-            const { TAG } = process.env;
-            const globber = await glob.create('out/*.tgz');
-            await upload({ github, context }, await globber.glob(), TAG);
+          GITHUB_API_KEY: ${{ secrets.GITHUB_API_KEY }}

.github/workflows/verify-release-notes.yml

@@ -1,27 +0,0 @@
-name: Verify Release Notes
-
-on:
-  pull_request:
-    branches:
-      - main
-    types: [opened, synchronize, reopened, labeled]
-
-jobs:
-  verify-release-notes:
-    name: Verify Release Notes
-    runs-on: ubuntu-latest
-    steps:
-      # We *only* need to check out the .github/ directory.
-      # The verify RELEASE_NOTES script uses the GitHub API to verify that RELEASE_NOTES was
-      # modified.
-      - name: Check out action
-        uses: Bhacaz/checkout-files@73e17cfbe8d7e0c6b2672b20cb05a718e20d18d4
-        with:
-          files: .github
-          token: ${{ secrets.GITHUB_TOKEN }}
-      - name: Verify release notes
-        uses: ./.github/actions/verify-release-notes
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
-          pull-request-number: ${{ github.event.pull_request.number }}
-          release-notes-file: 'NEW_RELEASE_NOTES.md'

.github/workflows/web-continuous.yml

@@ -10,14 +10,14 @@ on:
 jobs:
   build-web:
     name: build-web
-    runs-on: ubuntu-22.04-16core
+    runs-on: macos-latest
 
     steps:
-      - uses: actions/checkout@v4.1.6
+      - uses: actions/checkout@v2.0.0
       - name: Run build script
         run: |
           cd build/web && printf "y" | ./build.sh continuous
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v1.0.0
         with:
           name: filament-web
           path: out/filament-release-web.tgz

.github/workflows/windows-continuous.yml

@@ -10,15 +10,15 @@ on:
 jobs:
   build-windows:
     name: build-windows
-    runs-on: windows-2019-32core
+    runs-on: windows-latest
 
     steps:
-      - uses: actions/checkout@v4.1.6
+      - uses: actions/checkout@v2.0.0
       - name: Run build script
         run: |
           build\windows\build-github.bat continuous
         shell: cmd
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v1.0.0
         with:
           name: filament-windows
           path: out/filament-windows.tgz

.gitignore

@@ -16,5 +16,3 @@ settings.json
 test*.png
 test*.json
 results
-/compile_commands.json
-/.cache

BUILDING.md

@@ -4,24 +4,29 @@
 
 To build Filament, you must first install the following tools:
 
-- CMake 3.19 (or more recent)
-- clang 14.0 (or more recent)
-- [ninja 1.10](https://github.com/ninja-build/ninja/wiki/Pre-built-Ninja-packages) (or more recent)
+- CMake 3.10 (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)
 
 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 Flamingo or more recent
+- Android Studio 4.1.0 or more recent
 - Android SDK
-- Android NDK 25.1 or higher
-- Java 17
+- Android NDK "side-by-side" 22.0 or higher
 
 ### Environment variables
 
-To build Filament for Android, make sure the environment variable `ANDROID_HOME` points to the
-location of your Android SDK.
+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.
 
 When building for WebGL, you'll also need to set `EMSDK`. See [WebAssembly](#webassembly).
 
@@ -40,46 +45,57 @@ inside the Filament source tree.
 
 To trigger an incremental debug build:
 
-```shell
-./build.sh debug
+```
+$ ./build.sh debug
 ```
 
 To trigger an incremental release build:
 
-```shell
-./build.sh release
+```
+$ ./build.sh release
 ```
 
 To trigger both incremental debug and release builds:
 
-```shell
-./build.sh debug release
+```
+$ ./build.sh debug release
 ```
 
-If build fails for some reasons, it may leave the `out/` directory in a broken state. You can
-force a clean build by adding the `-c` flag in that case.
-
 To install the libraries and executables in `out/debug/` and `out/release/`, add the `-i` flag.
-The script offers more features described by executing `build.sh -h`.
+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
 - `FILAMENT_USE_EXTERNAL_GLES3`:   Experimental: Compile Filament against OpenGL ES 3
+- `FILAMENT_USE_SWIFTSHADER`:      Compile Filament against SwiftShader
 - `FILAMENT_SKIP_SAMPLES`:         Don't build sample apps
 
 To turn an option on or off:
 
-```shell
-cd <cmake-build-directory>
-cmake . -DOPTION=ON       # Replace OPTION with the option name, set to ON / OFF
+```
+$ cd <cmake-build-directory>
+$ cmake . -DOPTION=ON       # Relace OPTION with the option name, set to ON / OFF
 ```
 
 Options can also be set with the CMake GUI.
@@ -88,14 +104,12 @@ Options can also be set with the CMake GUI.
 
 Make sure you've installed the following dependencies:
 
-- `clang-14` or higher
+- `clang-7` or higher
 - `libglu1-mesa-dev`
-- `libc++-14-dev` (`libcxx-devel` and `libcxx-static` on Fedora) or higher
-- `libc++abi-14-dev` (`libcxxabi-static` on Fedora) or higher
+- `libc++-7-dev` (`libcxx-devel` and `libcxx-static` on Fedora) or higher
+- `libc++abi-7-dev` (`libcxxabi-static` on Fedora) or higher
 - `ninja-build`
 - `libxi-dev`
-- `libxcomposite-dev` (`libXcomposite-devel` on Fedora)
-- `libxxf86vm-dev` (`libXxf86vm-devel` on Fedora)
 
 After dependencies have been installed, we highly recommend using the [easy build](#easy-build)
 script.
@@ -103,38 +117,38 @@ script.
 If you'd like to run `cmake` directly rather than using the build script, it can be invoked as
 follows, with some caveats that are explained further down.
 
-```shell
-mkdir out/cmake-release
-cd out/cmake-release
-cmake -G Ninja -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=../release/filament ../..
+```
+$ mkdir out/cmake-release
+$ cd out/cmake-release
+$ cmake -G Ninja -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=../release/filament ../..
 ```
 
 Your Linux distribution might default to `gcc` instead of `clang`, if that's the case invoke
 `cmake` with the following command:
 
-```shell
-mkdir out/cmake-release
-cd out/cmake-release
-# Or use a specific version of clang, for instance /usr/bin/clang-14
-CC=/usr/bin/clang CXX=/usr/bin/clang++ CXXFLAGS=-stdlib=libc++ \
-  cmake -G Ninja -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=../release/filament ../..
+```
+$ mkdir out/cmake-release
+$ cd out/cmake-release
+# Or use a specific version of clang, for instance /usr/bin/clang-7
+$ CC=/usr/bin/clang CXX=/usr/bin/clang++ CXXFLAGS=-stdlib=libc++ \
+    cmake -G Ninja -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=../release/filament ../..
 ```
 
 You can also export the `CC` and `CXX` environment variables to always point to `clang`. Another
 solution is to use `update-alternatives` to both change the default compiler, and point to a
 specific version of clang:
 
-```shell
-update-alternatives --install /usr/bin/clang clang /usr/bin/clang-14 100
-update-alternatives --install /usr/bin/clang++ clang++ /usr/bin/clang++-14 100
-update-alternatives --install /usr/bin/cc cc /usr/bin/clang 100
-update-alternatives --install /usr/bin/c++ c++ /usr/bin/clang++ 100
+```
+$ update-alternatives --install /usr/bin/clang clang /usr/bin/clang-7 100
+$ update-alternatives --install /usr/bin/clang++ clang++ /usr/bin/clang++-7 100
+$ update-alternatives --install /usr/bin/cc cc /usr/bin/clang 100
+$ update-alternatives --install /usr/bin/c++ c++ /usr/bin/clang++ 100
 ```
 
 Finally, invoke `ninja`:
 
-```shell
-ninja
+```
+$ ninja
 ```
 
 This will build Filament, its tests and samples, and various host tools.
@@ -144,20 +158,25 @@ This will build Filament, its tests and samples, and various host tools.
 To compile Filament you must have the most recent version of Xcode installed and you need to
 make sure the command line tools are setup by running:
 
-```shell
-xcode-select --install
+```
+$ xcode-select --install
 ```
 
-If you wish to run the Vulkan backend instead of the default Metal backend, you must install
-the LunarG SDK, enable "System Global Components", and reboot your machine.
+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:
 
-```shell
-mkdir out/cmake-release
-cd out/cmake-release
-cmake -G Ninja -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=../release/filament ../..
-ninja
+```
+$ mkdir out/cmake-release
+$ cd out/cmake-release
+$ cmake -G Ninja -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=../release/filament ../..
+$ ninja
 ```
 
 ### iOS
@@ -165,24 +184,24 @@ ninja
 The easiest way to build Filament for iOS is to use `build.sh` and the
 `-p ios` flag. For instance to build the debug target:
 
-```shell
-./build.sh -p ios debug
+```
+$ ./build.sh -p ios debug
 ```
 
 See [ios/samples/README.md](./ios/samples/README.md) for more information.
 
 ### Windows
 
-#### Building on Windows with Visual Studio 2019 or later
+#### Building on Windows with Visual Studio 2019
 
 Install the following components:
 
-- [Visual Studio 2019 or later](https://www.visualstudio.com/downloads)
-- [Windows SDK](https://developer.microsoft.com/en-us/windows/downloads/windows-sdk/)
+- [Visual Studio 2019](https://www.visualstudio.com/downloads)
+- [Windows 10 SDK](https://developer.microsoft.com/en-us/windows/downloads/windows-10-sdk)
 - [Python 3.7](https://www.python.org/ftp/python/3.7.0/python-3.7.0.exe)
 - [CMake 3.14 or later](https://github.com/Kitware/CMake/releases/download/v3.14.7/cmake-3.14.7-win64-x64.msi)
 
-The latest Windows SDK can also be installed by opening Visual Studio and selecting _Get Tools and
+The latest Windows SDK can also by installed by opening Visual Studio and selecting _Get Tools and
 Features..._ under the _Tools_ menu.
 
 By default, Windows treats the file system as case insensitive. Please do not enable case
@@ -192,10 +211,10 @@ using `fsutil.exe file queryCaseSensitiveInfo`.
 Next, open `x64 Native Tools Command Prompt for VS 2019`, create a working directory, and run
 CMake in it:
 
-```bat
-mkdir out
-cd out
-cmake ..
+```
+> mkdir out
+> cd out
+> cmake ..
 ```
 
 Open the generated solution file `TNT.sln` in Visual Studio.
@@ -205,15 +224,15 @@ target in the _Solution Explorer_ and choose _Build_ to build a specific target.
 
 For example, build the `material_sandbox` sample and run it from the `out` directory with:
 
-```bat
-samples\Debug\material_sandbox.exe ..\assets\models\monkey\monkey.obj
+```
+> samples\Debug\material_sandbox.exe ..\assets\models\monkey\monkey.obj
 ```
 
 You can also use CMake to invoke the build without opening Visual Studio. For example, from the
 `out` folder run the following command.
 
-```bat
-cmake --build . --target gltf_viewer --config Release
+```
+> cmake --build . --target gltf_viewer --config Release
 ```
 
 ### Android
@@ -238,8 +257,8 @@ To build Android on Windows machines, see [android/Windows.md](android/Windows.m
 The easiest way to build Filament for Android is to use `build.sh` and the
 `-p android` flag. For instance to build the release target:
 
-```shell
-./build.sh -p android release
+```
+$ ./build.sh -p android release
 ```
 
 Run `build.sh -h` for more information.
@@ -249,23 +268,23 @@ Run `build.sh -h` for more information.
 Invoke CMake in a build directory of your choice, inside of filament's directory. The commands
 below show how to build Filament for ARM 64-bit (`aarch64`).
 
-```shell
-mkdir out/android-build-release-aarch64
-cd out/android-build-release-aarch64
-cmake -G Ninja -DCMAKE_TOOLCHAIN_FILE=../../build/toolchain-aarch64-linux-android.cmake \
-      -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=../android-release/filament ../..
+```
+$ mkdir out/android-build-release-aarch64
+$ cd out/android-build-release-aarch64
+$ cmake -G Ninja -DCMAKE_TOOLCHAIN_FILE=../../build/toolchain-aarch64-linux-android.cmake \
+        -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=../android-release/filament ../..
 ```
 
 And then invoke `ninja`:
 
-```shell
-ninja install
+```
+$ ninja install
 ```
 
 or
 
-```shell
-ninja install/strip
+```
+$ ninja install/strip
 ```
 
 This will generate Filament's Android binaries in `out/android-release`. This location is important
@@ -297,12 +316,12 @@ AAR.
 Alternatively you can build the AAR from the command line by executing the following in the
 `android/` directory:
 
-```shell
-./gradlew -Pcom.google.android.filament.dist-dir=../../out/android-release/filament assembleRelease
+```
+$ ./gradlew -Pfilament_dist_dir=../../out/android-release/filament assembleRelease
 ```
 
-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).
+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).
 
 #### Using Filament's AAR
 
@@ -312,7 +331,7 @@ sure to add the newly created module as a dependency to your application.
 If you do not wish to include all supported ABIs, make sure to create the appropriate flavors in
 your Gradle build file. For example:
 
-```gradle
+```
 flavorDimensions 'cpuArch'
 productFlavors {
     arm8 {
@@ -354,9 +373,9 @@ started, follow the instructions for building Filament on your platform ([macOS]
 Next, you need to install the Emscripten SDK. The following instructions show how to install the
 same version that our continuous builds use.
 
-```shell
+```
 cd <your chosen parent folder for the emscripten SDK>
-curl -L https://github.com/emscripten-core/emsdk/archive/refs/tags/3.1.15.zip > emsdk.zip
+curl -L https://github.com/emscripten-core/emsdk/archive/2.0.12.zip > emsdk.zip
 unzip emsdk.zip ; mv emsdk-* emsdk ; cd emsdk
 python ./emsdk.py install latest
 python ./emsdk.py activate latest
@@ -365,18 +384,20 @@ source ./emsdk_env.sh
 
 After this you can invoke the [easy build](#easy-build) script as follows:
 
-```shell
+```
 export EMSDK=<your chosen home for the emscripten SDK>
 ./build.sh -p webgl release
 ```
 
 The EMSDK variable is required so that the build script can find the Emscripten SDK. The build
 creates a `samples` folder that can be used as the root of a simple static web server. Note that you
-cannot open the HTML directly from the filesystem due to CORS. We recommend using the emrun tool
-to create a quick localhost server:
+cannot open the HTML directly from the filesystem due to CORS. One way to deal with this is to
+use Python to create a quick localhost server:
 
-```shell
-emrun out/cmake-webgl-release/web/samples --no_browser --port 8000
+```
+cd out/cmake-webgl-release/web/samples
+python3 -m http.server     # Python 3
+python -m SimpleHTTPServer # Python 2.7
 ```
 
 You can then open http://localhost:8000/suzanne.html in your web browser.
@@ -396,18 +417,17 @@ Some of the samples accept FBX/OBJ meshes while others rely on the `filamesh` fi
 generate a `filamesh ` file from an FBX/OBJ asset, run the `filamesh` tool
 (`./tools/filamesh/filamesh` in your build directory):
 
-```shell
+```
 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) 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:
+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:
 
-```shell
-cmgen -f ktx -x ./ibls/ my_ibl.exr
+```
+cmgen -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
@@ -425,72 +445,42 @@ value is the desired roughness between 0 and 1.
 
 ## Generating C++ documentation
 
-To generate the documentation you must first install `doxygen` and `graphviz`, then run the
+To generate the documentation you must first install `doxygen` and `graphviz`, then run the 
 following commands:
 
-```shell
-cd filament/filament
-doxygen docs/doxygen/filament.doxygen
+```
+$ cd filament/filament
+$ doxygen docs/doxygen/filament.doxygen
 ```
 
 Finally simply open `docs/html/index.html` in your web browser.
 
-## Software Rasterization
+## SwiftShader
 
-We have tested swiftshader and Mesa for software rasterization on the Vulkan/GL backends.
+To try out Filament's Vulkan support with SwiftShader, first build SwiftShader and set the
+`SWIFTSHADER_LD_LIBRARY_PATH` variable to the folder that contains `libvk_swiftshader.dylib`:
 
-To use this for Vulkan, please first make sure that the [Vulkan SDK](https://www.lunarg.com/vulkan-sdk/) is
-installed on your machine. If you are doing a manual installation of the SDK on Linux, you will have
-to source `setup-env.sh` in the SDK's root folder to make sure the Vulkan loader is the first lib loaded.
-
-### Swiftshader (Vulkan) [tested on macOS and Linux]
-
-First, build SwiftShader
-
-```shell
+```
 git clone https://github.com/google/swiftshader.git
 cd swiftshader/build
 cmake .. &&  make -j
+export SWIFTSHADER_LD_LIBRARY_PATH=`pwd`
 ```
 
-and then set `VK_ICD_FILENAMES` to the ICD json produced in the build. For example,
-```shell
-export VK_ICD_FILENAMES=/Users/user/swiftshader/build/Darwin/vk_swiftshader_icd.json
-```
+Next, go to your Filament repo and use the [easy build](#easy-build) script with `-t`.
 
-Build and run Filament as usual and specify the Vulkan backend when creating the Engine.
+## SwiftShader for CI
 
-### Mesa's LLVMPipe (GL) and Lavapipe (Vulkan) [tested on Linux]
-
-We will only cover steps that build Mesa from source. The official documentation of Mesa mentioned
-that in general precompiled libraries [are **not** made available](https://docs.mesa3d.org/precompiled.html).
-
-Download the repo and make sure you have the build depedencies. For example (assuming an Ubuntu/Debian distro),
-```shell
-git clone https://gitlab.freedesktop.org/mesa/mesa.git
-sudo apt-get build-dep mesa
-```
-
-To build both the GL and Vulkan rasterizers,
-
-```shell
-cd mesa
-mkdir -p out
-meson setup builddir/ -Dprefix=$(pwd)/out -Dglx=xlib -Dgallium-drivers=swrast -Dvulkan-drivers=swrast
-meson install -C builddir/
-```
-
-For GL, we need to ensure that we load the GL lib from the mesa output directory.  For example, to run
-the debug `gltf_viewer`, we would execute
-```shell
-LD_LIBRARY_PATH=/Users/user/mesa/out/lib/x86_64-linux-gnu \
-    ./out/cmake-debug/samples/gltf_viewer -a opengl
-```
-
-For Vulkan, we need to set the path to the ICD json, which tells the loader where to find the driver
-library. To run `gltf_viewer`, we would execute
-```shell
-VK_ICD_FILENAMES=/Users/user/mesa/out/share/vulkan/icd.d/lvp_icd.x86_64.json \
-    ./out/cmake-debug/samples/gltf_viewer -a vulkan
+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,15 +1,7 @@
 # ==================================================================================================
 # CMake
 # ==================================================================================================
-cmake_minimum_required(VERSION 3.19)
-
-# ==================================================================================================
-# Toolchain configuration
-# ==================================================================================================
-if (APPLE AND NOT IOS)
-    # This must be set before project() is called
-    set(CMAKE_OSX_DEPLOYMENT_TARGET 10.15 CACHE STRING "")
-endif()
+cmake_minimum_required(VERSION 3.10)
 
 # ==================================================================================================
 # Project declaration
@@ -19,8 +11,12 @@ 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)
+
 option(FILAMENT_ENABLE_LTO "Enable link-time optimizations if supported by the compiler" OFF)
 
 option(FILAMENT_SKIP_SAMPLES "Don't build samples" OFF)
@@ -29,59 +25,22 @@ 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_EGL_ON_LINUX "Use EGL for OpenGL in Linux builds" OFF)
-
-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)
-
-option(FILAMENT_ENABLE_ASAN_UBSAN "Enable Address and Undefined Behavior Sanitizers" OFF)
-
-option(FILAMENT_ENABLE_TSAN "Enable Thread Sanitizer" OFF)
-
-option(FILAMENT_ENABLE_FEATURE_LEVEL_0 "Enable Feature Level 0" ON)
-
-option(FILAMENT_ENABLE_MULTIVIEW "Enable multiview for Filament" OFF)
-
-option(FILAMENT_SUPPORTS_OSMESA "Enable OSMesa (headless GL context) for Filament" 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."
 )
 
-set(FILAMENT_PER_RENDER_PASS_ARENA_SIZE_IN_MB "3" CACHE STRING
-    "Per render pass arena size. Must be roughly 1 MB larger than FILAMENT_PER_FRAME_COMMANDS_SIZE_IN_MB, default 3."
+set(FILAMENT_PER_FRAME_COMMANDS_SIZE_IN_MB "1" CACHE STRING
+    "Size of the high-level draw commands buffer. Rule of thumb, 1 MB less than FILAMENT_PER_RENDER_PASS_ARENA_SIZE_IN_MB, default 1."
 )
 
-set(FILAMENT_PER_FRAME_COMMANDS_SIZE_IN_MB "2" CACHE STRING
-    "Size of the high-level draw commands buffer. Rule of thumb, 1 MB less than FILAMENT_PER_RENDER_PASS_ARENA_SIZE_IN_MB, default 2."
+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_MIN_COMMAND_BUFFERS_SIZE_IN_MB "2" 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 2."
+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."
-)
-
-set(FILAMENT_BACKEND_DEBUG_FLAG "" CACHE STRING
-    "A debug flag meant for enabling/disabling backend debugging paths"
-)
-
-set(FILAMENT_OSMESA_PATH "" CACHE STRING
-    "Path to the OSMesa header and lib"
-)
-
-# Enable exceptions by default in spirv-cross.
-set(SPIRV_CROSS_EXCEPTIONS_TO_ASSERTIONS OFF)
-
 # ==================================================================================================
 # CMake policies
 # ==================================================================================================
@@ -94,30 +53,25 @@ endif()
 # ==================================================================================================
 find_program(CCACHE_PROGRAM ccache)
 if (CCACHE_PROGRAM)
-    if (WIN32)
-        set(CMAKE_C_COMPILER_LAUNCHER   "${CCACHE_PROGRAM}")
-        set(CMAKE_CXX_COMPILER_LAUNCHER "${CCACHE_PROGRAM}")
+    set(C_LAUNCHER   "${CCACHE_PROGRAM}")
+    set(CXX_LAUNCHER "${CCACHE_PROGRAM}")
+
+    configure_file(build/launch-c.in   launch-c)
+    configure_file(build/launch-cxx.in launch-cxx)
+
+    execute_process(COMMAND chmod a+rx
+        "${CMAKE_BINARY_DIR}/launch-c"
+        "${CMAKE_BINARY_DIR}/launch-cxx"
+    )
+
+    if (CMAKE_GENERATOR STREQUAL "Xcode")
+        set(CMAKE_XCODE_ATTRIBUTE_CC         "${CMAKE_BINARY_DIR}/launch-c")
+        set(CMAKE_XCODE_ATTRIBUTE_CXX        "${CMAKE_BINARY_DIR}/launch-cxx")
+        set(CMAKE_XCODE_ATTRIBUTE_LD         "${CMAKE_BINARY_DIR}/launch-c")
+        set(CMAKE_XCODE_ATTRIBUTE_LDPLUSPLUS "${CMAKE_BINARY_DIR}/launch-cxx")
     else()
-        set(C_LAUNCHER   "${CCACHE_PROGRAM}")
-        set(CXX_LAUNCHER "${CCACHE_PROGRAM}")
-
-        configure_file(build/launch-c.in   launch-c)
-        configure_file(build/launch-cxx.in launch-cxx)
-
-        execute_process(COMMAND chmod a+rx
-            "${CMAKE_CURRENT_BINARY_DIR}/launch-c"
-            "${CMAKE_CURRENT_BINARY_DIR}/launch-cxx"
-        )
-
-        if (CMAKE_GENERATOR STREQUAL "Xcode")
-            set(CMAKE_XCODE_ATTRIBUTE_CC         "${CMAKE_CURRENT_BINARY_DIR}/launch-c")
-            set(CMAKE_XCODE_ATTRIBUTE_CXX        "${CMAKE_CURRENT_BINARY_DIR}/launch-cxx")
-            set(CMAKE_XCODE_ATTRIBUTE_LD         "${CMAKE_CURRENT_BINARY_DIR}/launch-c")
-            set(CMAKE_XCODE_ATTRIBUTE_LDPLUSPLUS "${CMAKE_CURRENT_BINARY_DIR}/launch-cxx")
-        else()
-            set(CMAKE_C_COMPILER_LAUNCHER        "${CMAKE_CURRENT_BINARY_DIR}/launch-c")
-            set(CMAKE_CXX_COMPILER_LAUNCHER      "${CMAKE_CURRENT_BINARY_DIR}/launch-cxx")
-        endif()
+        set(CMAKE_C_COMPILER_LAUNCHER        "${CMAKE_BINARY_DIR}/launch-c")
+        set(CMAKE_CXX_COMPILER_LAUNCHER      "${CMAKE_BINARY_DIR}/launch-cxx")
     endif()
 endif()
 
@@ -131,55 +85,33 @@ set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 # ==================================================================================================
 if (UNIX AND NOT APPLE AND NOT ANDROID AND NOT WEBGL)
     set(LINUX TRUE)
-else()
-    # since cmake 3.25 LINUX is automatically set based on CMAKE_SYSTEM_NAME, which the android
-    # cmake files are setting to "Linux".
-    set(LINUX FALSE)
 endif()
 
 if (LINUX)
-    if (NOT FILAMENT_OSMESA_PATH STREQUAL "")
-        if (NOT EXISTS ${FILAMENT_OSMESA_PATH}/)
-            message(FATAL_ERROR "Cannot find specified OSMesa build directory: ${FILAMENT_OSMESA_PATH}")
-        endif()
-        set(FILAMENT_SUPPORTS_OSMESA TRUE)
+    if (FILAMENT_SUPPORTS_XCB)
+        add_definitions(-DFILAMENT_SUPPORTS_XCB)
     endif()
 
-    if (FILAMENT_SUPPORTS_WAYLAND)
-        add_definitions(-DFILAMENT_SUPPORTS_WAYLAND)
-        set(FILAMENT_SUPPORTS_X11 FALSE)
-    elseif (FILAMENT_SUPPORTS_EGL_ON_LINUX)
-        add_definitions(-DFILAMENT_SUPPORTS_EGL_ON_LINUX)
-        set(FILAMENT_SUPPORTS_X11 FALSE)
-    elseif (FILAMENT_SUPPORTS_OSMESA)
-        set(FILAMENT_SUPPORTS_X11 FALSE)
-        add_definitions(-DFILAMENT_SUPPORTS_OSMESA)
-    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_SUPPORTS_XLIB)
-            add_definitions(-DFILAMENT_SUPPORTS_X11)
-            set(FILAMENT_SUPPORTS_X11 TRUE)
-        endif()
+    if (FILAMENT_SUPPORTS_XLIB)
+        add_definitions(-DFILAMENT_SUPPORTS_XLIB)
     endif()
 endif()
 
-if (ANDROID OR WEBGL OR IOS OR FILAMENT_LINUX_IS_MOBILE)
+if (ANDROID OR WEBGL OR IOS)
     set(IS_MOBILE_TARGET TRUE)
 endif()
 
-if (ANDROID)
-    add_definitions(-D__ANDROID_UNAVAILABLE_SYMBOLS_ARE_WEAK__)
+if (NOT ANDROID AND NOT WEBGL AND NOT IOS)
+    set(IS_HOST_PLATFORM TRUE)
 endif()
 
-if (NOT ANDROID AND NOT WEBGL AND NOT IOS AND NOT FILAMENT_LINUX_IS_MOBILE)
-    set(IS_HOST_PLATFORM TRUE)
+if (IOS)
+    # Remove the headerpad_max_install_names linker flag on iOS. It causes warnings when linking
+    # executables with bitcode.
+    string(REPLACE "-Wl,-headerpad_max_install_names" "" CMAKE_C_LINK_FLAGS ${CMAKE_C_LINK_FLAGS})
+    string(REPLACE "-Wl,-headerpad_max_install_names" "" CMAKE_CXX_LINK_FLAGS ${CMAKE_CXX_LINK_FLAGS})
+    string(REPLACE "-Wl,-headerpad_max_install_names" "" CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS ${CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS})
+    string(REPLACE "-Wl,-headerpad_max_install_names" "" CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS ${CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS})
 endif()
 
 if (WIN32)
@@ -193,35 +125,27 @@ 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})
-        add_compile_options(
-            $<$<CONFIG:>:/MT>
-            $<$<CONFIG:Debug>:/MTd>
-            $<$<CONFIG:Release>:/MT>
-        )
+        set(CRT_FLAGS_RELEASE "/MT")
+        set(CRT_FLAGS_DEBUG "/MTd")
     else()
-        add_compile_options(
-            $<$<CONFIG:>:/MD>
-            $<$<CONFIG:Debug>:/MDd>
-            $<$<CONFIG:Release>:/MD>
-        )
+        set(CRT_FLAGS_RELEASE "/MD")
+        set(CRT_FLAGS_DEBUG "/MDd")
     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} /Z7")
-    set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO} /Z7")
+    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")
 
     # In RELEASE, also generate PDBs.
-    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /Zi")
-    set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /Zi")
+    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")
 
     # 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} /Z7")
-    set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /Z7")
+    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")
 
     # Special settings when building on CI.
     if (${FILAMENT_WINDOWS_CI_BUILD})
@@ -238,21 +162,6 @@ if (WIN32)
             # we don't need them on CI.
             string(REPLACE "/INCREMENTAL" "/INCREMENTAL:NO" ${LinkerFlag} ${${LinkerFlag}})
         endforeach()
-
-        # We turn off compile-time optimizations for CI, as options that speed up the compile-time
-        # (e.g. /MP) might increase memory usage, leading to instabilities on limited CI machines.
-        option(FILAMENT_SHORTEN_MSVC_COMPILATION "Shorten compile-time in Visual Studio" OFF)
-    else()
-        option(FILAMENT_SHORTEN_MSVC_COMPILATION "Shorten compile-time in Visual Studio" ON)
-    endif()
-
-    if (MSVC)
-        if (FILAMENT_SHORTEN_MSVC_COMPILATION)
-            # enable multi-processor compilation
-            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP")
-            # disable run-time STL checks to improve tools (e.g. matc) performance
-            set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /D_ITERATOR_DEBUG_LEVEL=0")
-        endif()
     endif()
 endif()
 
@@ -325,15 +234,15 @@ if (MSVC)
     set(CXX_STANDARD "/std:c++latest")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_STANDARD} /W0 /Zc:__cplusplus")
 else()
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_STANDARD} -fstrict-aliasing -Wno-unknown-pragmas -Wno-unused-function -Wno-deprecated-declarations")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_STANDARD} -fstrict-aliasing -Wno-unknown-pragmas -Wno-unused-function")
 endif()
 
 if (FILAMENT_USE_EXTERNAL_GLES3)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUSE_EXTERNAL_GLES3")
 endif()
 
-if (FILAMENT_SUPPORTS_EGL_ON_LINUX)
-  set(EGL TRUE)
+if (FILAMENT_USE_SWIFTSHADER)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DFILAMENT_USE_SWIFTSHADER")
 endif()
 
 if (WIN32)
@@ -356,12 +265,11 @@ if (LINUX)
 endif()
 
 if (ANDROID)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC -Werror=unguarded-availability")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC")
 endif()
 
 if (CYGWIN)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-exceptions -fno-rtti")
-    set(SPIRV_CROSS_EXCEPTIONS_TO_ASSERTIONS ON)
 endif()
 
 if (MSVC)
@@ -377,41 +285,22 @@ 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
 # ==================================================================================================
-if (NOT MSVC AND NOT IOS)
-    # Omitting stack frame pointers prevents the generation of readable stack traces in crash reports on iOS
-    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -fomit-frame-pointer")
-endif()
-
 if (NOT MSVC)
-    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -ffunction-sections -fdata-sections")
+    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -fomit-frame-pointer")
+
+    # These aren't compatible with -fembed-bitcode (and seem to have no effect on Apple platforms anyway)
+    if (NOT IOS)
+        set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -ffunction-sections -fdata-sections")
+    endif()
 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 IOS OR WEBGL)
-    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -fno-exceptions -fno-rtti")
-    set(SPIRV_CROSS_EXCEPTIONS_TO_ASSERTIONS ON)
-
-    if (ANDROID OR WEBGL)
-        # Omitting unwind info prevents the generation of readable stack traces in crash reports on iOS
-        set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -fno-unwind-tables -fno-asynchronous-unwind-tables")
-    endif()
-endif()
-
-# Turn off exceptions on iOS debug as well. This fixes an availability error we see when using
-# std::visit, which is not supported on iOS 11.0 when exceptions are enabled.
-if (IOS)
-    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fno-exceptions")
-    set(SPIRV_CROSS_EXCEPTIONS_TO_ASSERTIONS ON)
+    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -fno-exceptions -fno-unwind-tables -fno-asynchronous-unwind-tables -fno-rtti")
 endif()
 
 # With WebGL, we disable RTTI even for debug builds because we pass emscripten::val back and forth
@@ -421,23 +310,13 @@ if (WEBGL)
     set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fno-rtti")
 endif()
 
-if (WEBGL_PTHREADS)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread")
-endif()
-
 # ==================================================================================================
 # Debug compiler flags
 # ==================================================================================================
-if (FILAMENT_ENABLE_ASAN_UBSAN)
-   set(EXTRA_SANITIZE_OPTIONS "-fsanitize=address -fsanitize=undefined")
-endif()
-if (FILAMENT_ENABLE_TSAN)
-   set(EXTRA_SANITIZE_OPTIONS "-fsanitize=thread")
-endif()
-if (ANDROID)
-    # keep STL debug infos (mimics what the NDK does)
-    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fno-limit-debug-info")
-endif()
+# ASAN is deactivated for now because:
+#  -fsanitize=undefined causes extremely long link times
+#  -fsanitize=address causes a crash with assimp, which we can't explain for now
+#set(EXTRA_SANITIZE_OPTIONS "-fsanitize=undefined -fsanitize=address")
 if (NOT MSVC AND NOT WEBGL)
     set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fstack-protector")
 endif()
@@ -456,13 +335,8 @@ endif()
 if (NOT WEBGL)
     set(GC_SECTIONS "-Wl,--gc-sections")
 endif()
-
 set(B_SYMBOLIC_FUNCTIONS "-Wl,-Bsymbolic-functions")
 
-if (ANDROID)
-set(BINARY_ALIGNMENT "-Wl,-z,max-page-size=16384")
-endif()
-
 if (APPLE)
     set(GC_SECTIONS "-Wl,-dead_strip")
     set(B_SYMBOLIC_FUNCTIONS "")
@@ -476,10 +350,10 @@ if (APPLE)
 endif()
 
 set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${GC_SECTIONS}")
-set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${GC_SECTIONS} ${B_SYMBOLIC_FUNCTIONS} ${BINARY_ALIGNMENT}")
+set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${GC_SECTIONS} ${B_SYMBOLIC_FUNCTIONS}")
 
-if (WEBGL_PTHREADS)
-    set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -pthread")
+if (WEBGL)
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -s USE_WEBGL2=1")
 endif()
 
 # ==================================================================================================
@@ -491,12 +365,6 @@ 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)
@@ -539,29 +407,6 @@ else()
     option(FILAMENT_DISABLE_MATOPT "Disable material optimizations" ON)
 endif()
 
-# This only affects the prebuilt shader files in gltfio and samples, not filament library.
-# The value can be either "instanced", "multiview", or "none"
-set(FILAMENT_SAMPLES_STEREO_TYPE "none" CACHE STRING
-    "Stereoscopic type that shader files in gltfio and samples are built for."
-)
-string(TOLOWER "${FILAMENT_SAMPLES_STEREO_TYPE}" FILAMENT_SAMPLES_STEREO_TYPE)
-if (NOT FILAMENT_SAMPLES_STEREO_TYPE STREQUAL "instanced"
-    AND NOT FILAMENT_SAMPLES_STEREO_TYPE STREQUAL "multiview"
-    AND NOT FILAMENT_SAMPLES_STEREO_TYPE STREQUAL "none")
-    message(FATAL_ERROR "Invalid stereo type: \"${FILAMENT_SAMPLES_STEREO_TYPE}\" choose either \"instanced\",  \"multiview\", or \"none\" ")
-endif ()
-
-# Compiling samples for multiview implies enabling multiview feature as well.
-if (FILAMENT_SAMPLES_STEREO_TYPE STREQUAL "multiview")
-    set(FILAMENT_ENABLE_MULTIVIEW ON)
-endif ()
-
-# Define backend flag for debug only
-if (CMAKE_BUILD_TYPE STREQUAL "Debug" AND NOT FILAMENT_BACKEND_DEBUG_FLAG STREQUAL "")
-    add_definitions(-DFILAMENT_BACKEND_DEBUG_FLAG=${FILAMENT_BACKEND_DEBUG_FLAG})
-    unset(FILAMENT_BACKEND_DEBUG_FLAG)
-endif()
-
 # ==================================================================================================
 # Material compilation flags
 # ==================================================================================================
@@ -575,9 +420,9 @@ endif()
 
 set(MATC_API_FLAGS )
 
-if (FILAMENT_SUPPORTS_OPENGL)
-    set(MATC_API_FLAGS ${MATC_API_FLAGS} -a opengl)
-endif()
+# TODO: Add a flag to build Filament without support for OpenGL.
+set(MATC_API_FLAGS ${MATC_API_FLAGS} -a opengl)
+
 if (FILAMENT_SUPPORTS_VULKAN)
     set(MATC_API_FLAGS ${MATC_API_FLAGS} -a vulkan)
 endif()
@@ -585,19 +430,8 @@ if (FILAMENT_SUPPORTS_METAL)
     set(MATC_API_FLAGS ${MATC_API_FLAGS} -a metal)
 endif()
 
-# Disable ESSL 1.0 code generation.
-if (NOT FILAMENT_ENABLE_FEATURE_LEVEL_0)
-    set(MATC_API_FLAGS ${MATC_API_FLAGS} -1)
-endif()
-
-# Enable debug info (preserves names in SPIR-V)
-if (FILAMENT_ENABLE_MATDBG)
-    set(MATC_OPT_FLAGS ${MATC_OPT_FLAGS} -d)
-endif()
-
-# Disable optimizations
 if (FILAMENT_DISABLE_MATOPT)
-    set(MATC_OPT_FLAGS ${MATC_OPT_FLAGS} -g)
+    set(MATC_OPT_FLAGS -g)
 endif()
 
 set(MATC_BASE_FLAGS ${MATC_API_FLAGS} -p ${MATC_TARGET} ${MATC_OPT_FLAGS})
@@ -615,15 +449,11 @@ if (NOT DIST_ARCH)
     if (CMAKE_OSX_ARCHITECTURES MATCHES ".*;.*")
         set(DIST_ARCH "universal")
     else()
-        if (NOT "${CMAKE_OSX_ARCHITECTURES}" STREQUAL "")
+        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()
@@ -641,18 +471,14 @@ function(list_licenses OUTPUT MODULES)
     foreach(module ${_MODULES})
         set(license_path "../../third_party/${module}/LICENSE")
         get_filename_component(fullname "${license_path}" ABSOLUTE)
-        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()
+        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")
     endforeach()
     configure_file(${FILAMENT}/build/licenses.inc.in ${OUTPUT})
-endfunction()
+endfunction(list_licenses)
 
 set(COMBINE_SCRIPT "${CMAKE_CURRENT_SOURCE_DIR}/build/linux/combine-static-libs.sh")
 if (WIN32)
@@ -665,12 +491,7 @@ function(combine_static_libs TARGET OUTPUT DEPS)
     # Loop through the dependent libraries and query their location on disk.
     set(DEPS_FILES )
     foreach(DEPENDENCY ${DEPS})
-        if (TARGET ${DEPENDENCY})
-            get_property(dep_type TARGET ${DEPENDENCY} PROPERTY TYPE)
-            if (dep_type STREQUAL "STATIC_LIBRARY")
-                list(APPEND DEPS_FILES "$<TARGET_FILE:${DEPENDENCY}>")
-            endif()
-        endif()
+        list(APPEND DEPS_FILES "$<TARGET_FILE:${DEPENDENCY}>")
     endforeach()
 
     add_custom_command(
@@ -690,6 +511,28 @@ else()
     set(IMPORT_EXECUTABLES ${FILAMENT}/${IMPORT_EXECUTABLES_DIR}/ImportExecutables-${CMAKE_BUILD_TYPE}.cmake)
 endif()
 
+# ==================================================================================================
+# Try to find Vulkan if the SDK is installed, otherwise fall back to the bundled version.
+# This needs to stay in our top-level CMakeLists because it sets up variables that are used by the
+# "bluevk" and "samples" targets.
+# ==================================================================================================
+
+if (FILAMENT_USE_SWIFTSHADER)
+    if (NOT FILAMENT_SUPPORTS_VULKAN)
+        message(ERROR "SwiftShader is only useful when Vulkan is enabled.")
+    endif()
+    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}\")
+    endif()
+endif()
+
 # ==================================================================================================
 # Common Functions
 # ==================================================================================================
@@ -722,7 +565,7 @@ function(get_resgen_vars ARCHIVE_DIR ARCHIVE_NAME)
         set(RESGEN_OUTPUTS "${OUTPUTS}" PARENT_SCOPE)
         set(RESGEN_FLAGS -qx ${ARCHIVE_DIR} -p ${ARCHIVE_NAME} PARENT_SCOPE)
         set(RESGEN_SOURCE "${ARCHIVE_DIR}/${ARCHIVE_NAME}${ASM_SUFFIX}.S" PARENT_SCOPE)
-        set(RESGEN_SOURCE_FLAGS "-I'${ARCHIVE_DIR}' ${ASM_ARCH_FLAG}" PARENT_SCOPE)
+        set(RESGEN_SOURCE_FLAGS "-I${ARCHIVE_DIR} ${ASM_ARCH_FLAG}" PARENT_SCOPE)
     endif()
 endfunction()
 
@@ -737,35 +580,29 @@ 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}/ktxreader)
 add_subdirectory(${LIBRARIES}/math)
 add_subdirectory(${LIBRARIES}/mathio)
-add_subdirectory(${LIBRARIES}/uberz)
 add_subdirectory(${LIBRARIES}/utils)
 add_subdirectory(${LIBRARIES}/viewer)
 add_subdirectory(${FILAMENT}/filament)
 add_subdirectory(${FILAMENT}/shaders)
-add_subdirectory(${EXTERNAL}/basisu/tnt)
 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/tnt)
-add_subdirectory(${EXTERNAL}/mikktspace)
+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)
 
-# Note that this has to be placed after mikktspace in order for combine_static_libs to work.
-add_subdirectory(${LIBRARIES}/geometry)
-
 if (FILAMENT_BUILD_FILAMAT OR IS_HOST_PLATFORM)
     # spirv-tools must come before filamat, as filamat relies on the presence of the
     # spirv-tools_SOURCE_DIR variable.
@@ -783,8 +620,10 @@ endif()
 if (FILAMENT_SUPPORTS_VULKAN)
     add_subdirectory(${LIBRARIES}/bluevk)
     add_subdirectory(${EXTERNAL}/vkmemalloc/tnt)
-    set(SPIRV_HEADERS_SKIP_EXAMPLES ON)
-    add_subdirectory(${EXTERNAL}/spirv-headers)
+endif()
+
+if (APPLE)
+    add_subdirectory(${EXTERNAL}/moltenvk/tnt)
 endif()
 
 set(FILAMENT_SAMPLES_BINARY_DIR ${PROJECT_BINARY_DIR}/samples)
@@ -795,16 +634,18 @@ if (WEBGL)
 endif()
 
 if (IS_HOST_PLATFORM)
-    if (FILAMENT_SUPPORTS_OPENGL)
-        add_subdirectory(${LIBRARIES}/bluegl)
-    endif()
-    if (NOT FILAMENT_SKIP_SDL2)
-      add_subdirectory(${LIBRARIES}/filamentapp)
-    endif()
+    add_subdirectory(${LIBRARIES}/bluegl)
+    add_subdirectory(${LIBRARIES}/filamentapp)
     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}/libassimp/tnt)
     add_subdirectory(${EXTERNAL}/libpng/tnt)
     add_subdirectory(${EXTERNAL}/libsdl2/tnt)
@@ -817,19 +658,14 @@ if (IS_HOST_PLATFORM)
     add_subdirectory(${TOOLS}/glslminifier)
     add_subdirectory(${TOOLS}/matc)
     add_subdirectory(${TOOLS}/matinfo)
-    if (NOT WIN32)  # matedit not yet supported on Windows
-        add_subdirectory(${TOOLS}/matedit)
-    endif()
     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)
-    add_subdirectory(${TOOLS}/uberz)
 endif()
 
 # Generate exported executables for cross-compiled builds (Android, WebGL, and iOS)
 if (NOT CMAKE_CROSSCOMPILING)
-    export(TARGETS matc cmgen filamesh mipgen resgen uberz glslminifier FILE ${IMPORT_EXECUTABLES})
+    export(TARGETS matc cmgen filamesh mipgen resgen glslminifier FILE ${IMPORT_EXECUTABLES})
 endif()

CODE_STYLE.md

@@ -164,7 +164,8 @@ private:
 
 ### Strings
 
-- Never use `std::string` in the Filament core renderer. Prefer `utils::CString` or `std::string_view`.
+- Never use `std::string` in the Filament core renderer. Prefer `utils::CString` or
+  `utils::StaticString`.
 - When using `std::string` in tools, always include the `std::` qualifier to disambiguate it
   from other string types.
 

CONTRIBUTING.md

@@ -27,7 +27,7 @@ again.
 
 ## Code Style
 
-See [CODE_STYLE.md](/CODE_STYLE.md)
+See [CodeStyle.md](/CODE_STYLE.md)
 
 ## Code reviews
 

LICENSE

@@ -187,7 +187,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright 2023 The Android Open Source Project
+   Copyright [yyyy] [name of copyright owner]
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

NEW_RELEASE_NOTES.md

@@ -1,10 +0,0 @@
-# Filament Release Notes log
-
-**If you are merging a PR into main**: please add the release note below, under the *Release notes
-for next branch cut* header.
-
-**If you are cherry-picking a commit into an rc/ branch**: add the release note under the
-appropriate header in [RELEASE_NOTES.md](./RELEASE_NOTES.md).
-
-## Release notes for next branch cut
-- vk: fix stage pool gc logic

README.md

@@ -31,28 +31,50 @@ repositories {
 }
 
 dependencies {
-    implementation 'com.google.android.filament:filament-android:1.56.0'
+    implementation 'com.google.android.filament:filament-android:1.9.21'
 }
 ```
 
 Here are all the libraries available in the group `com.google.android.filament`:
 
-| 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. |
-| [![filament-android-debug](https://maven-badges.herokuapp.com/maven-central/com.google.android.filament/filament-android-debug/badge.svg?subject=filament-android-debug)](https://maven-badges.herokuapp.com/maven-central/com.google.android.filament/filament-android-debug)  | Debug version of `filament-android`. |
-| [![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`. |
-| [![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`. |
-| [![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. |
+[![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.
 
 ### iOS
 
 iOS projects can use CocoaPods to install the latest release:
 
-```shell
-pod 'Filament', '~> 1.56.0'
 ```
+pod 'Filament', '~> 1.9.21'
+```
+
+### Snapshots
+
+If you prefer to live on the edge, you can download a continuous build by following the following
+steps:
+
+1. Find the [commit](https://github.com/google/filament/commits/main) you're interested in.
+2. Click the green check mark under the commit message.
+3. Click on the _Details_ link for the platform you're interested in.
+4. On the top right, click on the _Artifacts_ dropdown and choose an artifact.
 
 ## Documentation
 
@@ -75,12 +97,25 @@ pod 'Filament', '~> 1.56.0'
 ![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
+- Java/JNI API for Android, Linux, macOS and Windows
 - JavaScript API
 
 ### Backends
@@ -96,7 +131,6 @@ pod 'Filament', '~> 1.56.0'
 - Clustered forward renderer
 - Cook-Torrance microfacet specular BRDF
 - Lambertian diffuse BRDF
-- Custom lighting/surface shading
 - HDR/linear lighting
 - Metallic workflow
 - Clear coat
@@ -107,29 +141,21 @@ pod 'Filament', '~> 1.56.0'
 - Image-based lighting
 - Physically-based camera (shutter speed, sensitivity and aperture)
 - Physical light units
-- Point lights, spot lights, and directional light
-- Specular anti-aliasing
-- Point, spot, and directional light shadows
+- Point lights, spot lights and directional light
+- Spot and directional light shadows
 - Cascaded shadows
-- EVSM, PCSS, DPCF, or PCF shadows
-- Transparent shadows
+- VSM or PCF shadows
 - Contact shadows
 - Screen-space ambient occlusion
-- Screen-space reflections
 - Screen-space refraction
 - Global fog
-- Dynamic resolution (with support for AMD FidelityFX FSR)
-
-### Post processing
-
 - HDR bloom
 - Depth of field bokeh
-- 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
+- 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
 
 ### glTF 2.0
 
@@ -141,9 +167,9 @@ pod 'Filament', '~> 1.56.0'
   - [x] Points
   - [x] Lines
   - [ ] Line Loop
-  - [x] Line Strip
+  - [ ] Line Strip
   - [x] Triangles
-  - [x] Triangle Strip
+  - [ ] Triangle Strip
   - [ ] Triangle Fan
 
 - Animation
@@ -158,19 +184,12 @@ pod 'Filament', '~> 1.56.0'
   - [x] KHR_draco_mesh_compression
   - [x] KHR_lights_punctual
   - [x] KHR_materials_clearcoat
-  - [x] KHR_materials_emissive_strength
-  - [x] KHR_materials_ior
   - [x] KHR_materials_pbrSpecularGlossiness
   - [x] KHR_materials_sheen
   - [x] KHR_materials_transmission
   - [x] KHR_materials_unlit
-  - [x] KHR_materials_variants
-  - [x] KHR_materials_volume
-  - [x] KHR_materials_specular
   - [x] KHR_mesh_quantization
-  - [x] KHR_texture_basisu
   - [x] KHR_texture_transform
-  - [x] EXT_meshopt_compression
 
 
 ## Rendering with Filament
@@ -236,11 +255,22 @@ 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 `libs/filamentapp/` 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 `samples/app/` which contains the code
+that creates a native window with SDL2 and initializes the Filament engine, renderer and views.
 
-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).
+### 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`.
 
 ### Android
 
@@ -271,10 +301,6 @@ 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
@@ -297,9 +323,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
@@ -319,7 +345,6 @@ 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

@@ -9,15 +9,26 @@ Before starting, ensure that each of these branches is up-to-date with origin:
 - rc/$RELEASE
 - main
 
-## 0. Check versions.
+## 0. Make sure the rc/$RELEASE branch has the correct version.
 
-Make sure the rc/$RELEASE branch has the correct Filament version. It should have the version
-corresponding to its name, $RELEASE.
+It should have the version corresponding to its name, $RELEASE.
 
-Make sure `MATERIAL_VERSION` has been bumped to a new version if this is a MAJOR or MINOR release
-(first two version numbers).
+## 1. Update RELEASE_NOTES.md on the rc branch.
 
-## 1. Bump Filament versions on main to $RELEASE.
+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:
 
@@ -28,24 +39,54 @@ build/common/bump-version.sh $RELEASE
 Commit changes to main with the title:
 
 ```
-Release Filament $RELEASE
+Bump version to $RELEASE
 ```
 
 Do not push to origin yet.
 
-## 2. Update RELEASE_NOTES.md on main.
+## 3. Cherry-pick RELEASE_NOTES change from rc branch to main.
 
-Create a new header in RELEASE_NOTES.md for $NEXT_RELEASE. Copy the release notes in
-NEW_RELEASE_NOTES.md to RELEASE_NOTES.md under the new header. Clear NEW_RELEASE_NOTES.md.
+```
+git cherry-pick rc/$RELEASE
+```
 
-Amend these changes to the "Release Filament $RELEASE" commit.
+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
 ```
 
-## 3. Run release script.
+## 4. Run release script.
 
 ```
 build/common/release.sh rc/$RELEASE rc/$NEXT_RELEASE
@@ -54,26 +95,24 @@ 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.
 
-## 4. Push the release branch.
+## 5. Push the release branch.
 
 ```
 git push origin release
 ```
 
-## 5. Create the GitHub 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.
 
-## 6. Delete the old rc branch (optional).
-
-This step is optional. The old rc branch may be left alive for a few weeks for posterity.
+## 7. Delete the old rc branch.
 
 ```
 git push origin --delete rc/$RELEASE
 ```
 
-## 7. Bump the version on the new rc branch to $NEXT_RELEASE.
+## 8. Bump the version on the new rc branch to $NEXT_RELEASE.
 
 ```
 git checkout rc/$NEXT_RELEASE
@@ -86,57 +125,14 @@ Commit the changes to rc/$NEXT_RELEASE with the title:
 Bump version to $NEXT_RELEASE
 ```
 
-## 8. Push main.
+## 9. Push main.
 
 ```
 git push origin main
 ```
 
-## 9. Push the new rc branch.
+## 10. Push the new rc branch.
 
 ```
-git push origin -u rc/$NEXT_RELEASE
+git push origin rc/$NEXT_RELEASE
 ```
-
-## 10. Rebuild the GitHub release (if failed).
-
-Sometimes the GitHub release job will fail. In this case, you can manually re-run the release job.
-
-### Remove any assets uploaded to the release (if needed).
-
-For example, if rebuilding the Mac release, ensure that the `filament-<version>-mac.tgz` artifact
-is removed from the release assets.
-
-### Update the release branch (if needed).
-
-If you need to add one or more new commits to the release, perform the following:
-
-First, push the new commit(s) to the `release` branch.
-
-Then, with the release branch checked out with the new commit(s), run
-
-```
-git tag -f -a <release tagname>
-git push origin -f <release tagname>
-```
-
-This will update and force push the tag.
-
-### Re-run the GitHub release workflow
-
-Navigate to [Filament's release
-workflow](https://github.com/google/filament/actions/workflows/release.yml). Hit the _Run workflow_
-dropdown. Modify _Platform to build_ and _Release tag to build_, then hit _Run workflow_. This will
-initiate a new release run.
-
-## 11. Kick off the npm and CocoaPods release jobs
-
-Navigate to [Filament's npm deploy
-workflow](https://github.com/google/filament/actions/workflows/npm-deploy.yml).
-Hit the _Run workflow_ dropdown. Modify _Release tag to deploy_ to the tag corresponding to this
-release (for example, v1.42.2).
-
-Navigate to [Filament's CocoaPods deploy
-workflow](https://github.com/google/filament/actions/workflows/cocopods-deploy.yml).
-Hit the _Run workflow_ dropdown. Modify _Release tag to deploy_ to the tag corresponding to this
-release (for example, v1.42.2).

android/Windows.md

@@ -122,20 +122,20 @@ The Gradle project used to generate the AAR is located at `<filament>\android`.
 
 ```
 cd android
-gradlew -Pcom.google.android.filament.dist-dir=..\out\android-release\filament assembleRelease
+gradlew -Pfilament_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 `com.google.android.filament.abis` parameter:
+If you're only interested in building for a single ABI, you'll need to pass a `filament_abis` parameter:
 
 ```
-gradlew -Pcom.google.android.filament.dist-dir=..\out\android-release\filament assembleRelease -Pcom.google.android.filament.abis=x86
+gradlew -Pfilament_dist_dir=..\out\android-release\filament assembleRelease -Pfilament_abis=x86
 ```
 
-If you're only interested in building SDK, you may skip samples build by passing a `com.google.android.filament.skip-samples` flag:
+If you're only interested in building SDK, you may skip samples build by passing a `filament_skip_samples` flag:
 
 ```
-gradlew -Pcom.google.android.filament.dist-dir=..\out\android-release\filament assembleRelease -Pcom.google.android.filament.skip-samples
+gradlew -Pfilament_dist_dir=..\out\android-release\filament assembleRelease -Pfilament_skip_samples
 ```
 
 

android/build.gradle

@@ -1,43 +1,38 @@
 // This script accepts the following parameters:
 //
-// com.google.android.filament.dist-dir
+// 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.
 //
-// com.google.android.filament.tools-dir
+// filament_tools_dir
 //     Path to the Filament distribution/install directory for desktop.
 //     This directory must contain bin/matc.
 //
-// com.google.android.filament.exclude-vulkan
+// filament_exclude_vulkan
 //     When set, support for Vulkan will be excluded.
 //
-// com.google.android.filament.matdbg
-//     When set, enables matdbg
-//
-// com.google.android.filament.matnopt
-//     When set, disable shader optimizations.
-//
-// com.google.android.filament.skip-samples
+// filament_skip_samples
 //     Exclude samples from the project. Useful to speed up compilation.
 //
-// com.google.android.filament.abis
+// 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 -Pcom.google.android.filament.dist-dir=../dist-android-release \
-//               -Pcom.google.android.filament.abis=x86 \
-//               assembleRelease
+//     ./gradlew -Pfilament_dist_dir=../dist-android-release assembleRelease -Pfilament_abis=x86
 
 // Publishing to Maven Central:
 //   - Build and upload artifacts with ./gradlew publish
-//   - Close and release staging repo on Nexus with ./gradlew closeAndReleaseStagingRepository
+//   - Close and release staging repo on Nexus with ./gradlew closeAndReleaseRepository
 //
 // The following is needed in ~/gradle/gradle.properties:
 //
-//     sonatypeUsername=nexus_user
-//     sonatypePassword=nexus_password
+//     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
@@ -45,102 +40,75 @@
 //
 
 buildscript {
-    def path = providers
-            .gradleProperty("com.google.android.filament.dist-dir")
-            .get()
-
-    def directory = objects.fileProperty().fileValue(new File(path)).getAsFile().get()
-    def filamentPath = directory.absolutePath
-
+    def filamentPath = file("../out/android-release/filament").absolutePath
+    if (project.hasProperty("filament_dist_dir")) {
+        filamentPath = file(project.property("filament_dist_dir")).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 = providers
-            .gradleProperty("com.google.android.filament.exclude-vulkan")
-            .isPresent()
-
-    def matdbg = providers
-            .gradleProperty("com.google.android.filament.matdbg")
-            .isPresent()
-
-    def matnopt = providers
-            .gradleProperty("com.google.android.filament.matnopt")
-            .isPresent()
+    def excludeVulkan = project.hasProperty("filament_exclude_vulkan")
 
     def abis = ["arm64-v8a", "armeabi-v7a", "x86_64", "x86"]
-    def newAbis = providers
-            .gradleProperty("com.google.android.filament.abis")
-            .get()
-            .split(',')
-    if (!newAbis.contains("all")) {
-        abis = newAbis
+    if (project.hasProperty("filament_abis")) {
+        def newAbis = project.property("filament_abis").split(',')
+        if (!newAbis.contains("all")) {
+            abis = newAbis
+        }
     }
 
+    // Our minSdkVersion is 19.
     ext.versions = [
-        'jdk': 17,
-        'minSdk': 21,
-        'targetSdk': 34,
-        'compileSdk': 34,
-        'kotlin': '2.0.21',
-        'kotlin_coroutines': '1.9.0',
-        'buildTools': '35.0.0',
-        'ndk': '27.0.11718014',
-        'androidx_core': '1.13.1',
-        'androidx_annotations': '1.9.0'
+        'minSdk': 19,
+        'targetSdk': 30,
+        'compileSdk': 30,
+        'kotlin': '1.4.31',
+        'buildTools': '30.0.3',
+        'ndk': '22.0.7026061'
     ]
 
     ext.deps = [
         'androidx': [
-            'annotations': "androidx.annotation:annotation:${versions.androidx_annotations}",
-            'core': "androidx.core:core:${versions.androidx_core}",
+            'annotations': "androidx.annotation:annotation:1.1.0",
+            'core': "androidx.core:core:1.3.0",
         ],
-        '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}",
-        ]
+        'kotlin': "org.jetbrains.kotlin:kotlin-stdlib-jdk8:${versions.kotlin}"
     ]
 
     dependencies {
-        classpath 'com.android.tools.build:gradle:8.6.1'
+        classpath 'com.android.tools.build:gradle:4.1.3'
         classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${versions.kotlin}"
     }
 
     ext.cmakeArgs = [
-        "--no-warn-unused-cli",
         "-DANDROID_PIE=ON",
         "-DANDROID_PLATFORM=21",
         "-DANDROID_STL=c++_static",
         "-DFILAMENT_DIST_DIR=${filamentPath}".toString(),
-        "-DFILAMENT_SUPPORTS_VULKAN=${excludeVulkan ? 'OFF' : 'ON'}".toString(),
-        "-DFILAMENT_ENABLE_MATDBG=${matdbg ? 'ON' : 'OFF'}".toString(),
-        "-DFILAMENT_DISABLE_MATOPT=${matnopt ? 'ON' : 'OFF'}".toString()
+        "-DFILAMENT_SUPPORTS_VULKAN=${excludeVulkan ? 'OFF' : 'ON'}".toString()
     ]
 
     ext.cppFlags = [
         "-std=c++17",
+        "-Wno-unused-command-line-argument",
+        // Required to support API levels below 23
+        "-Wl,--hash-style=both",
         "-fno-stack-protector",
         "-fno-exceptions",
         "-fno-unwind-tables",
         "-fno-asynchronous-unwind-tables",
         "-fno-rtti",
         "-ffast-math",
-        "-fno-finite-math-only",
         "-ffp-contract=fast",
         "-fvisibility-inlines-hidden",
         "-fvisibility=hidden",
         "-fomit-frame-pointer",
         "-ffunction-sections",
         "-fdata-sections",
-        "-no-canonical-prefixes",
-        "-Wformat",
-        "-Werror=format-security",
-        "-Wno-unused-command-line-argument",
         "-Wl,--gc-sections",
         "-Wl,-Bsymbolic-functions",
-        "-Wl,--hash-style=both", // Required to support API levels below 23
     ]
 
     ext.abis = abis
@@ -148,22 +116,19 @@ buildscript {
     repositories {
         mavenCentral()
         google()
+        jcenter()
     }
 }
 
 plugins {
-    id "io.github.gradle-nexus.publish-plugin" version "1.3.0"
+    id 'io.codearte.nexus-staging' version '0.22.0'
 }
 
-// See https://github.com/gradle-nexus/publish-plugin
-// Publish to https://oss.sonatype.org/ (not s01)
-nexusPublishing {
+// Nexus Staging configuration
+// See https://github.com/Codearte/gradle-nexus-staging-plugin/
+nexusStaging {
     packageGroup = 'com.google.android'
-    repositories {
-        sonatype {
-            stagingProfileId = '9a75a224a4f17b'
-        }
-    }
+    stagingProfileId = '9a75a224a4f17b'
 }
 
 subprojects {
@@ -173,6 +138,7 @@ subprojects {
     repositories {
         mavenCentral()
         google()
+        jcenter()
     }
 
     if (!name.startsWith("sample")) {
@@ -195,16 +161,13 @@ subprojects {
                 }
 
                 ndk {
-                    //noinspection ChromeOsAbiSupport
                     abiFilters(*rootProject.ext.abis)
                 }
-
-                consumerProguardFiles '../proguard-rules.pro'
             }
 
+
             externalNativeBuild {
                 cmake {
-                    version "3.19.0+"
                     path "CMakeLists.txt"
                 }
             }
@@ -216,8 +179,8 @@ subprojects {
             }
 
             compileOptions {
-                sourceCompatibility versions.jdk
-                targetCompatibility versions.jdk
+                sourceCompatibility JavaVersion.VERSION_1_8
+                targetCompatibility JavaVersion.VERSION_1_8
             }
         }
     }
@@ -226,8 +189,7 @@ subprojects {
 gradle.taskGraph.whenReady {
     gradle.taskGraph.allTasks.each {
         it.onlyIf {
-            !it.project.ext.has('isSample') ||
-                    !project.hasProperty('com.google.android.filament.skip-samples')
+            !it.project.ext.has('isSample') || !project.hasProperty('filament_skip_samples')
          }
     }
 }

android/buildSrc/build.gradle

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

android/common/CallbackUtils.cpp

@@ -16,10 +16,8 @@
 
 #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,
@@ -34,7 +32,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);
         }
@@ -45,12 +43,59 @@ 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,
+        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);
+}
+
+JniBufferCallback::~JniBufferCallback() {
+    releaseCallbackJni(mEnv, mCallbackUtils, mHandler, mCallback);
+}
+
+void JniBufferCallback::invoke(void*, size_t, void* user) {
+    JniBufferCallback* data = reinterpret_cast<JniBufferCallback*>(user);
+    delete data;
+}
+
+// -----------------------------------------------------------------------------------------------
+
+JniImageCallback* JniImageCallback::make(filament::Engine* 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);
+}
+
+JniImageCallback::~JniImageCallback() {
+    releaseCallbackJni(mEnv, mCallbackUtils, mHandler, mCallback);
+}
+
+void JniImageCallback::invoke(void*, void* user) {
+    JniImageCallback* data = reinterpret_cast<JniImageCallback*>(user);
+    delete data;
+}
+
 // -----------------------------------------------------------------------------------------------
 
 JniCallback* JniCallback::make(JNIEnv* env, jobject handler, jobject callback) {
@@ -58,63 +103,17 @@ JniCallback* JniCallback::make(JNIEnv* env, jobject handler, jobject callback) {
 }
 
 JniCallback::JniCallback(JNIEnv* env, jobject handler, jobject callback)
-        : mHandler(env->NewGlobalRef(handler)),
-          mCallback(env->NewGlobalRef(callback)) {
+        : mEnv(env)
+        , 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);
+JniCallback::~JniCallback() {
+    releaseCallbackJni(mEnv, mCallbackUtils, mHandler, mCallback);
 }
 
-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)
-        : JniCallback(env, handler, callback),
-        mBuffer(std::move(buffer)) {
-}
-
-JniBufferCallback::~JniBufferCallback() = default;
-
-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*,
-        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)
-        : JniCallback(env, handler, callback),
-        mImage(image) {
-}
-
-JniImageCallback::~JniImageCallback() = default;
-
-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;
+void JniCallback::invoke(void* user) {
+    JniCallback* data = reinterpret_cast<JniCallback*>(user);
+    delete data;
 }

android/common/CallbackUtils.h

@@ -18,14 +18,13 @@
 
 #include <jni.h>
 
+#include "common/CallbackUtils.h"
 #include "common/NioUtils.h"
 
-#include <backend/CallbackHandler.h>
-
 #include <filament/Engine.h>
 
 struct CallbackJni {
-#ifdef __ANDROID__
+#ifdef ANDROID
     jclass handlerClass = nullptr;
     jmethodID post = nullptr;
 #endif
@@ -36,60 +35,57 @@ struct CallbackJni {
 void acquireCallbackJni(JNIEnv* env, CallbackJni& callbackUtils);
 void releaseCallbackJni(JNIEnv* env, CallbackJni callbackUtils, jobject handler, jobject callback);
 
-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
+struct JniBufferCallback {
     static JniBufferCallback* make(filament::Engine* engine,
             JNIEnv* env, jobject handler, jobject callback, AutoBuffer&& buffer);
 
-    // execute the callback on the java thread and destroy ourselves
-    static void postToJavaAndDestroy(void*, size_t, void* user);
+    static void invoke(void* buffer, size_t n, void* user);
 
 private:
     JniBufferCallback(JNIEnv* env, jobject handler, jobject callback, AutoBuffer&& buffer);
-    virtual ~JniBufferCallback();
+    JniBufferCallback(JniBufferCallback const &) = delete;
+    JniBufferCallback(JniBufferCallback&&) = delete;
+    ~JniBufferCallback();
+
+    JNIEnv* mEnv;
+    jobject mHandler;
+    jobject mCallback;
     AutoBuffer mBuffer;
+    CallbackJni mCallbackUtils;
 };
 
-struct JniImageCallback : public JniCallback {
-    // create a JniImageCallback
+struct JniImageCallback {
     static JniImageCallback* make(filament::Engine* engine, JNIEnv* env, jobject handler,
             jobject runnable, long image);
 
-    // execute the callback on the java thread and destroy ourselves
-    static void postToJavaAndDestroy(void*, void* user);
+    static void invoke(void* image, void* user);
 
 private:
     JniImageCallback(JNIEnv* env, jobject handler, jobject runnable, long image);
-    virtual ~JniImageCallback();
+    JniImageCallback(JniImageCallback const &) = delete;
+    JniImageCallback(JniImageCallback&&) = delete;
+    ~JniImageCallback();
+
+    JNIEnv* mEnv;
+    jobject mHandler;
+    jobject mCallback;
     long mImage;
+    CallbackJni mCallbackUtils;
+};
+
+struct JniCallback {
+    static JniCallback* make(JNIEnv* env, jobject handler, jobject runnable);
+
+    static void invoke(void* user);
+
+private:
+    JniCallback(JNIEnv* env, jobject handler, jobject runnable);
+    JniCallback(JniCallback const &) = delete;
+    JniCallback(JniCallback&&) = delete;
+    ~JniCallback();
+
+    JNIEnv* mEnv;
+    jobject mHandler;
+    jobject mCallback;
+    CallbackJni mCallbackUtils;
 };

android/common/NioUtils.h

@@ -38,10 +38,6 @@ 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,11 +1,13 @@
-cmake_minimum_required(VERSION 3.19)
-project(filamat-android)
+cmake_minimum_required(VERSION 3.6)
 
 option(FILAMENT_ENABLE_MATDBG "Enables Material debugger" OFF)
 
 set(FILAMENT_DIR ${FILAMENT_DIST_DIR})
 
 set(FILAMAT_FLAVOR "filamat")
+if(FILAMAT_LITE)
+    set(FILAMAT_FLAVOR "filamat_lite")
+endif()
 
 if (FILAMENT_SUPPORTS_VULKAN)
     message("Library filamat ignores Vulkan settings")
@@ -38,7 +40,6 @@ set(FILAMAT_INCLUDE_DIRS
 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")
-set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-z,max-page-size=16384")
 
 add_library(filamat-jni SHARED src/main/cpp/MaterialBuilder.cpp)
 target_include_directories(filamat-jni PRIVATE ${FILAMAT_INCLUDE_DIRS})

android/filamat-android/build.gradle

@@ -1,10 +1,18 @@
 android {
-    namespace 'com.google.android.filament.filamat'
+    flavorDimensions "functionality"
+    productFlavors {
+        full {
+            dimension "functionality"
+        }
 
-    publishing {
-        singleVariant("release") {
-            withSourcesJar()
-            withJavadocJar()
+        lite {
+            dimension "functionality"
+
+            externalNativeBuild {
+                cmake {
+                    arguments.add("-DFILAMAT_LITE=ON")
+                }
+            }
         }
     }
 }
@@ -18,9 +26,14 @@ apply from: rootProject.file('gradle/gradle-mvn-push.gradle')
 afterEvaluate { project ->
     publishing {
         publications {
-            release(MavenPublication) {
+            fullRelease(MavenPublication) {
                 artifactId = POM_ARTIFACT_ID_FULL
-                from components.release
+                from components.fullRelease
+            }
+
+            liteRelease(MavenPublication) {
+                artifactId = POM_ARTIFACT_ID_LITE
+                from components.liteRelease
             }
         }
     }

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

@@ -123,22 +123,19 @@ 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, jint precision, jstring name_) {
+        JNIEnv* env, jclass, jlong nativeBuilder, jint uniformType, jstring name_) {
     auto builder = (MaterialBuilder*) nativeBuilder;
     const char* name = env->GetStringUTFChars(name_, nullptr);
-    builder->parameter(name, (MaterialBuilder::UniformType) uniformType,
-            (MaterialBuilder::ParameterPrecision) precision);
+    builder->parameter((MaterialBuilder::UniformType) uniformType, 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, jint precision,
-        jstring name_) {
+        JNIEnv* env, jclass, jlong nativeBuilder, jint uniformType, jint size, jstring name_) {
     auto builder = (MaterialBuilder*) nativeBuilder;
     const char* name = env->GetStringUTFChars(name_, nullptr);
-    builder->parameter(name, (size_t) size, (MaterialBuilder::UniformType) uniformType,
-            (MaterialBuilder::ParameterPrecision) precision);
+    builder->parameter((MaterialBuilder::UniformType) uniformType, (size_t) size, name);
     env->ReleaseStringUTFChars(name_, name);
 }
 
@@ -148,8 +145,9 @@ Java_com_google_android_filament_filamat_MaterialBuilder_nMaterialBuilderSampler
         jint precision, jstring name_) {
     auto builder = (MaterialBuilder*) nativeBuilder;
     const char* name = env->GetStringUTFChars(name_, nullptr);
-    builder->parameter(name, (MaterialBuilder::SamplerType) samplerType,
-            (MaterialBuilder::SamplerFormat) format, (MaterialBuilder::ParameterPrecision) precision);
+    builder->parameter((MaterialBuilder::SamplerType) samplerType,
+            (MaterialBuilder::SamplerFormat) format, (MaterialBuilder::SamplerPrecision) precision,
+            name);
     env->ReleaseStringUTFChars(name_, name);
 }
 
@@ -250,13 +248,6 @@ Java_com_google_android_filament_filamat_MaterialBuilder_nMaterialBuilderMaskThr
     builder->maskThreshold(maskThreshold);
 }
 
-extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_filamat_MaterialBuilder_nMaterialBuilderAlphaToCoverage(JNIEnv*,
-        jclass, jlong nativeBuilder, jboolean enable) {
-    auto builder = (MaterialBuilder*) nativeBuilder;
-    builder->alphaToCoverage(enable);
-}
-
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_filamat_MaterialBuilder_nMaterialBuilderShadowMultiplier(
         JNIEnv*, jclass, jlong nativeBuilder, jboolean shadowMultiplier) {
@@ -264,13 +255,6 @@ 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) {
@@ -307,13 +291,6 @@ 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) {
@@ -376,10 +353,3 @@ Java_com_google_android_filament_filamat_MaterialBuilder_nMaterialBuilderVariant
     auto builder = (MaterialBuilder*) nativeBuilder;
     builder->variantFilter((uint8_t) variantFilter);
 }
-
-extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_filamat_MaterialBuilder_nMaterialBuilderUseLegacyMorphing(JNIEnv*,
-        jclass, jlong nativeBuilder) {
-    auto builder = (MaterialBuilder*) nativeBuilder;
-    builder->useLegacyMorphing();
-}

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

@@ -91,7 +91,7 @@ public class MaterialBuilder {
         SHADOW
     }
 
-    public enum ParameterPrecision {
+    public enum SamplerPrecision {
         LOW,
         MEDIUM,
         HIGH,
@@ -133,7 +133,7 @@ public class MaterialBuilder {
         FADE,                   // material is transparent and color is alpha-pre-multiplied,
                                 // affects specular lighting
         MULTIPLY,               // material darkens what's behind it
-        SCREEN                  // material brightens what's behind it
+        SCREN                   // material brightens what's behind it
     }
 
     public enum VertexDomain {
@@ -247,36 +247,19 @@ public class MaterialBuilder {
 
     @NonNull
     public MaterialBuilder uniformParameter(@NonNull UniformType type, String 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);
+        nMaterialBuilderUniformParameter(mNativeObject, type.ordinal(), name);
         return this;
     }
 
     @NonNull
     public MaterialBuilder uniformParameterArray(@NonNull UniformType type, int size, String 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);
+        nMaterialBuilderUniformParameterArray(mNativeObject, type.ordinal(), size, name);
         return this;
     }
 
     @NonNull
     public MaterialBuilder samplerParameter(@NonNull SamplerType type, SamplerFormat format,
-            ParameterPrecision precision, String name) {
+            SamplerPrecision precision, String name) {
         nMaterialBuilderSamplerParameter(
                 mNativeObject, type.ordinal(), format.ordinal(), precision.ordinal(), name);
         return this;
@@ -360,24 +343,12 @@ public class MaterialBuilder {
         return this;
     }
 
-    @NonNull
-    public MaterialBuilder alphaToCoverage(boolean enable) {
-        nMaterialBuilderAlphaToCoverage(mNativeObject, enable);
-        return this;
-    }
-
     @NonNull
     public MaterialBuilder shadowMultiplier(boolean shadowMultiplier) {
         nMaterialBuilderShadowMultiplier(mNativeObject, shadowMultiplier);
         return this;
     }
 
-    @NonNull
-    public MaterialBuilder transparentShadow(boolean transparentShadow) {
-        nMaterialBuilderTransparentShadow(mNativeObject, transparentShadow);
-        return this;
-    }
-
     @NonNull
     public MaterialBuilder specularAntiAliasing(boolean specularAntiAliasing) {
         nMaterialBuilderSpecularAntiAliasing(mNativeObject, specularAntiAliasing);
@@ -420,12 +391,6 @@ 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);
@@ -465,19 +430,6 @@ public class MaterialBuilder {
     @NonNull
     public MaterialBuilder variantFilter(int variantFilter) {
         nMaterialBuilderVariantFilter(mNativeObject, variantFilter);
-        useLegacyMorphing();
-        return this;
-    }
-
-    /**
-     * Legacy morphing uses the data in the {@link VertexBuffer.VertexAttribute} slots
-     * (<code>MORPH_POSITION_0</code>, etc) and is limited to 4 morph targets.
-     *
-     * @see RenderableManager.Builder#morphing()
-     */
-    @NonNull
-    public MaterialBuilder useLegacyMorphing() {
-        nMaterialBuilderUseLegacyMorphing(mNativeObject);
         return this;
     }
 
@@ -571,9 +523,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,
-            int precision, String name);
+            String name);
     private static native void nMaterialBuilderUniformParameterArray(long nativeBuilder, int type,
-            int size, int precision, String name);
+            int size, 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,
@@ -590,12 +542,9 @@ public class MaterialBuilder {
     private static native void nMaterialBuilderDepthCulling(long nativeBuilder, boolean enable);
     private static native void nMaterialBuilderDoubleSided(long nativeBuilder, boolean doubleSided);
     private static native void nMaterialBuilderMaskThreshold(long nativeBuilder, float mode);
-    private static native void nMaterialBuilderAlphaToCoverage(long nativeBuilder, boolean enable);
 
     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,
@@ -607,8 +556,6 @@ 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,
@@ -619,5 +566,4 @@ public class MaterialBuilder {
     private static native void nMaterialBuilderOptimization(long nativeBuilder, int optimization);
     private static native void nMaterialBuilderVariantFilter(long nativeBuilder,
             int variantFilter);
-    private static native void nMaterialBuilderUseLegacyMorphing(long nativeBuilder);
 }

android/filament-android/CMakeLists.txt

@@ -1,5 +1,4 @@
-cmake_minimum_required(VERSION 3.19)
-project(filament-android)
+cmake_minimum_required(VERSION 3.6)
 
 option(FILAMENT_SUPPORTS_VULKAN "Enables Vulkan on Android" OFF)
 option(FILAMENT_ENABLE_MATDBG "Enables Material debugger" OFF)
@@ -27,10 +26,6 @@ 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)
@@ -59,7 +54,6 @@ endif()
 
 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}")
-set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-z,max-page-size=16384")
 
 add_library(filament-jni SHARED
     src/main/cpp/BufferObject.cpp
@@ -75,19 +69,16 @@ add_library(filament-jni SHARED
     src/main/cpp/Material.cpp
     src/main/cpp/MaterialInstance.cpp
     src/main/cpp/MathUtils.cpp
-    src/main/cpp/MorphTargetBuffer.cpp
     src/main/cpp/RenderableManager.cpp
     src/main/cpp/Renderer.cpp
     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
@@ -106,6 +97,7 @@ target_link_libraries(filament-jni
     PRIVATE backend
     PRIVATE filaflat
     PRIVATE filabridge
+    PRIVATE geometry
     PRIVATE ibl-lite
     PRIVATE log
     PRIVATE GLESv3
@@ -113,12 +105,7 @@ target_link_libraries(filament-jni
     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>
@@ -127,7 +114,6 @@ target_link_libraries(filament-jni
 target_include_directories(filament-jni PRIVATE
         ..
         ${FILAMENT_DIR}/include
-        ../../filament/backend/include
         ../../third_party/robin-map
         ../../libs/utils/include)
 

android/filament-android/build.gradle

@@ -1,14 +1,3 @@
-android {
-    namespace 'com.google.android.filament'
-
-    publishing {
-        singleVariant("release") {
-            withSourcesJar()
-            withJavadocJar()
-        }
-    }
-}
-
 dependencies {
     implementation deps.androidx.annotations
 }

android/filament-android/libfilament-jni.map

@@ -13,9 +13,7 @@ LIBFILAMENT {
     *filament*IndirectLight*;
     *filament*LightManager*;
     *filament*Renderer*;
-    *filament*RenderTarget*;
     *filament*Scene*;
-    *filament*ToneMapper*;
     *filament*Transform*;
     *filament*Material*;
     *filament*IndexBuffer*;

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

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

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

@@ -18,8 +18,6 @@
 
 #include <filament/Camera.h>
 
-#include <utils/Entity.h>
-
 #include <math/mat4.h>
 
 using namespace filament;
@@ -84,13 +82,13 @@ Java_com_google_android_filament_Camera_nLookAt(JNIEnv*, jclass, jlong nativeCam
     camera->lookAt({eye_x, eye_y, eye_z}, {center_x, center_y, center_z}, {up_x, up_y, up_z});
 }
 
-extern "C" JNIEXPORT jdouble JNICALL
+extern "C" JNIEXPORT jfloat JNICALL
 Java_com_google_android_filament_Camera_nGetNear(JNIEnv*, jclass, jlong nativeCamera) {
     Camera *camera = (Camera *) nativeCamera;
     return camera->getNear();
 }
 
-extern "C" JNIEXPORT jdouble JNICALL
+extern "C" JNIEXPORT jfloat JNICALL
 Java_com_google_android_filament_Camera_nGetCullingFar(JNIEnv*, jclass,
         jlong nativeCamera) {
     Camera *camera = (Camera *) nativeCamera;
@@ -102,19 +100,10 @@ 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((math::mat4)*reinterpret_cast<const filament::math::mat4f*>(in));
+    camera->setModelMatrix(*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_) {
@@ -150,41 +139,21 @@ 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 = (math::mat4f)camera->getModelMatrix();
+    const filament::math::mat4f& m = 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 = (math::mat4f)camera->getViewMatrix();
+    const filament::math::mat4f& m = 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_) {

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

@@ -17,7 +17,6 @@
 #include <jni.h>
 
 #include <filament/ColorGrading.h>
-#include <filament/ToneMapper.h>
 
 #include <math/vec3.h>
 #include <math/vec4.h>
@@ -31,48 +30,28 @@ 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_nBuilderFormat(JNIEnv*, jclass, jlong nativeBuilder, jint format_) {
-    ColorGrading::Builder* builder = (ColorGrading::Builder*) nativeBuilder;
-    ColorGrading::LutFormat format = (ColorGrading::LutFormat) format_;
-    builder->format(format);
-}
-
-extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_ColorGrading_nBuilderDimensions(JNIEnv*, jclass, jlong nativeBuilder, jint dim_) {
-    ColorGrading::Builder* builder = (ColorGrading::Builder*) nativeBuilder;
-    builder->dimensions((uint8_t)dim_);
-}
-
-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_) {
@@ -80,35 +59,6 @@ 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,7 +16,6 @@
 
 #include <jni.h>
 
-#include <filament/Camera.h>
 #include <filament/Engine.h>
 
 #include <utils/Entity.h>
@@ -25,8 +24,15 @@
 using namespace filament;
 using namespace utils;
 
+extern "C" JNIEXPORT jlong JNICALL
+Java_com_google_android_filament_Engine_nCreateEngine(JNIEnv*, jclass, jlong backend,
+        jlong sharedContext) {
+    return (jlong) Engine::create((Engine::Backend) backend, nullptr, (void*) sharedContext);
+}
+
 extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_Engine_nDestroyEngine(JNIEnv*, jclass, jlong nativeEngine) {
+Java_com_google_android_filament_Engine_nDestroyEngine(JNIEnv*, jclass,
+        jlong nativeEngine) {
     Engine* engine = (Engine*) nativeEngine;
     Engine::destroy(&engine);
 }
@@ -38,11 +44,12 @@ 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*, jclass, jlong nativeEngine) {
+Java_com_google_android_filament_Engine_nGetBackend(JNIEnv* env,
+        jclass klass, jlong nativeEngine) {
     Engine* engine = (Engine*) nativeEngine;
     return (jlong) engine->getBackend();
 }
@@ -56,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*,
-        jclass, jlong nativeEngine, jint width, jint height, jlong flags) {
+Java_com_google_android_filament_Engine_nCreateSwapChainHeadless(JNIEnv* env,
+        jclass klass, jlong nativeEngine, jint width, jint height, jlong flags) {
     Engine* engine = (Engine*) nativeEngine;
     return (jlong) engine->createSwapChain(width, height, (uint64_t) flags);
 }
@@ -73,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);
 }
 
@@ -90,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);
 }
 
@@ -107,14 +114,21 @@ 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" JNIEXPORT jlong JNICALL
+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,
         jlong nativeEngine, jint entity_) {
     Engine* engine = (Engine*) nativeEngine;
     Entity& entity = *reinterpret_cast<Entity*>(&entity_);
@@ -129,12 +143,12 @@ Java_com_google_android_filament_Engine_nGetCameraComponent(JNIEnv*, jclass,
     return (jlong) engine->getCameraComponent(entity);
 }
 
-extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_Engine_nDestroyCameraComponent(JNIEnv*, jclass,
-        jlong nativeEngine, jint entity_) {
+extern "C" [[deprecated]] JNIEXPORT void JNICALL
+Java_com_google_android_filament_Engine_nDestroyCamera(JNIEnv*, jclass,
+        jlong nativeEngine, jlong nativeCamera) {
     Engine* engine = (Engine*) nativeEngine;
-    Entity& entity = *reinterpret_cast<Entity*>(&entity_);
-    engine->destroyCameraComponent(entity);
+    Camera *camera = (Camera *) nativeCamera;
+    engine->destroy(camera);
 }
 
 // Scene
@@ -150,7 +164,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);
 }
 
@@ -167,7 +181,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);
 }
 
@@ -177,7 +191,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);
 }
 
@@ -187,7 +201,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);
 }
 
@@ -195,23 +209,15 @@ 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);
 }
 
@@ -219,7 +225,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);
 }
 
@@ -235,7 +241,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);
 }
 
@@ -251,7 +257,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);
 }
 
@@ -271,178 +277,32 @@ Java_com_google_android_filament_Engine_nDestroyEntity(JNIEnv*, jclass,
     engine->destroy(entity);
 }
 
-
-extern "C" JNIEXPORT jboolean JNICALL
-Java_com_google_android_filament_Engine_nIsValidRenderer(JNIEnv*, jclass,
-        jlong nativeEngine, jlong nativeRenderer) {
-    Engine* engine = (Engine *)nativeEngine;
-    return (jboolean)engine->isValid((Renderer*)nativeRenderer);
-}
-
-extern "C" JNIEXPORT jboolean JNICALL
-Java_com_google_android_filament_Engine_nIsValidView(JNIEnv*, jclass,
-        jlong nativeEngine, jlong nativeView) {
-    Engine* engine = (Engine *)nativeEngine;
-    return (jboolean)engine->isValid((View*)nativeView);
-}
-
-extern "C" JNIEXPORT jboolean JNICALL
-Java_com_google_android_filament_Engine_nIsValidScene(JNIEnv*, jclass,
-        jlong nativeEngine, jlong nativeScene) {
-    Engine* engine = (Engine *)nativeEngine;
-    return (jboolean)engine->isValid((Scene*)nativeScene);
-}
-
-extern "C" JNIEXPORT jboolean JNICALL
-Java_com_google_android_filament_Engine_nIsValidFence(JNIEnv*, jclass,
-        jlong nativeEngine, jlong nativeFence) {
-    Engine* engine = (Engine *)nativeEngine;
-    return (jboolean)engine->isValid((Fence*)nativeFence);
-}
-
-extern "C" JNIEXPORT jboolean JNICALL
-Java_com_google_android_filament_Engine_nIsValidStream(JNIEnv*, jclass,
-        jlong nativeEngine, jlong nativeStream) {
-    Engine* engine = (Engine *)nativeEngine;
-    return (jboolean)engine->isValid((Stream*)nativeStream);
-}
-
-extern "C" JNIEXPORT jboolean JNICALL
-Java_com_google_android_filament_Engine_nIsValidIndexBuffer(JNIEnv*, jclass,
-        jlong nativeEngine, jlong nativeIndexBuffer) {
-    Engine* engine = (Engine *)nativeEngine;
-    return (jboolean)engine->isValid((IndexBuffer*)nativeIndexBuffer);
-}
-
-extern "C" JNIEXPORT jboolean JNICALL
-Java_com_google_android_filament_Engine_nIsValidVertexBuffer(JNIEnv*, jclass,
-        jlong nativeEngine, jlong nativeVertexBuffer) {
-    Engine* engine = (Engine *)nativeEngine;
-    return (jboolean)engine->isValid((VertexBuffer*)nativeVertexBuffer);
-}
-
-extern "C" JNIEXPORT jboolean JNICALL
-Java_com_google_android_filament_Engine_nIsValidSkinningBuffer(JNIEnv*, jclass,
-        jlong nativeEngine, jlong nativeSkinningBuffer) {
-    Engine* engine = (Engine *)nativeEngine;
-    return (jboolean)engine->isValid((SkinningBuffer*)nativeSkinningBuffer);
-}
-
-extern "C" JNIEXPORT jboolean JNICALL
-Java_com_google_android_filament_Engine_nIsValidIndirectLight(JNIEnv*, jclass,
-        jlong nativeEngine, jlong nativeIndirectLight) {
-    Engine* engine = (Engine *)nativeEngine;
-    return (jboolean)engine->isValid((IndirectLight*)nativeIndirectLight);
-}
-
-extern "C" JNIEXPORT jboolean JNICALL
-Java_com_google_android_filament_Engine_nIsValidMaterial(JNIEnv*, jclass,
-        jlong nativeEngine, jlong nativeMaterial) {
-    Engine* engine = (Engine *)nativeEngine;
-    return (jboolean)engine->isValid((Material*)nativeMaterial);
-}
-
-extern "C" JNIEXPORT jboolean JNICALL
-Java_com_google_android_filament_Engine_nIsValidMaterialInstance(JNIEnv*, jclass,
-        jlong nativeEngine, jlong nativeMaterial, jlong nativeMaterialInstance) {
-    Engine* engine = (Engine *)nativeEngine;
-    return (jboolean)engine->isValid((Material*)nativeMaterial,
-            (MaterialInstance*)nativeMaterialInstance);
-}
-
-extern "C" JNIEXPORT jboolean JNICALL
-        Java_com_google_android_filament_Engine_nIsValidExpensiveMaterialInstance(JNIEnv*, jclass,
-        jlong nativeEngine, jlong nativeMaterialInstance) {
-    Engine* engine = (Engine *)nativeEngine;
-    return (jboolean)engine->isValidExpensive((MaterialInstance*)nativeMaterialInstance);
-}
-
-extern "C" JNIEXPORT jboolean JNICALL
-Java_com_google_android_filament_Engine_nIsValidSkybox(JNIEnv*, jclass,
-        jlong nativeEngine, jlong nativeSkybox) {
-    Engine* engine = (Engine *)nativeEngine;
-    return (jboolean)engine->isValid((Skybox*)nativeSkybox);
-}
-
-extern "C" JNIEXPORT jboolean JNICALL
-Java_com_google_android_filament_Engine_nIsValidColorGrading(JNIEnv*, jclass,
-        jlong nativeEngine, jlong nativeColorGrading) {
-    Engine* engine = (Engine *)nativeEngine;
-    return (jboolean)engine->isValid((ColorGrading*)nativeColorGrading);
-}
-
-extern "C" JNIEXPORT jboolean JNICALL
-Java_com_google_android_filament_Engine_nIsValidTexture(JNIEnv*, jclass,
-        jlong nativeEngine, jlong nativeTexture) {
-    Engine* engine = (Engine *)nativeEngine;
-    return (jboolean)engine->isValid((Texture*)nativeTexture);
-}
-
-extern "C" JNIEXPORT jboolean JNICALL
-Java_com_google_android_filament_Engine_nIsValidRenderTarget(JNIEnv*, jclass,
-        jlong nativeEngine, jlong nativeTarget) {
-    Engine* engine = (Engine *)nativeEngine;
-    return (jboolean)engine->isValid((RenderTarget*)nativeTarget);
-}
-
-extern "C" JNIEXPORT jboolean JNICALL
-Java_com_google_android_filament_Engine_nIsValidSwapChain(JNIEnv*, jclass,
-        jlong nativeEngine, jlong nativeSwapChain) {
-    Engine* engine = (Engine *)nativeEngine;
-    return (jboolean)engine->isValid((SwapChain*)nativeSwapChain);
-}
-
 extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_Engine_nFlushAndWait(JNIEnv*, jclass,
+Java_com_google_android_filament_Engine_nFlushAndWait(JNIEnv *env, jclass clazz,
         jlong nativeEngine) {
     Engine* engine = (Engine*) nativeEngine;
     engine->flushAndWait();
 }
 
-extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_Engine_nFlush(JNIEnv*, jclass,
-        jlong nativeEngine) {
-    Engine* engine = (Engine*) nativeEngine;
-    engine->flush();
-}
-
-extern "C" JNIEXPORT jboolean JNICALL
-Java_com_google_android_filament_Engine_nIsPaused(JNIEnv*, jclass,
-        jlong nativeEngine) {
-    Engine* engine = (Engine*) nativeEngine;
-    return (jboolean)engine->isPaused();
-}
-
-extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_Engine_nSetPaused(JNIEnv*, jclass,
-        jlong nativeEngine, jboolean paused) {
-    Engine* engine = (Engine*) nativeEngine;
-    engine->setPaused(paused);
-}
-
-extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_Engine_nUnprotected(JNIEnv*, jclass,
-        jlong nativeEngine, jboolean paused) {
-    Engine* engine = (Engine*) nativeEngine;
-    engine->unprotected();
-}
-
 // 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();
 }
@@ -452,168 +312,3 @@ Java_com_google_android_filament_Engine_nGetJobSystem(JNIEnv*, jclass, jlong nat
     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();
-}
-
-extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_Engine_nSetAutomaticInstancingEnabled(JNIEnv*, jclass, jlong nativeEngine, jboolean enable) {
-    Engine* engine = (Engine*) nativeEngine;
-    engine->setAutomaticInstancingEnabled(enable);
-}
-
-extern "C" JNIEXPORT jboolean JNICALL
-Java_com_google_android_filament_Engine_nIsAutomaticInstancingEnabled(JNIEnv*, jclass, jlong nativeEngine) {
-    Engine* engine = (Engine*) nativeEngine;
-    return (jboolean)engine->isAutomaticInstancingEnabled();
-}
-
-extern "C" JNIEXPORT jlong JNICALL
-Java_com_google_android_filament_Engine_nGetMaxStereoscopicEyes(JNIEnv*, jclass, jlong nativeEngine) {
-    Engine* engine = (Engine*) nativeEngine;
-    return (jlong) engine->getMaxStereoscopicEyes();
-}
-
-
-extern "C" JNIEXPORT jint JNICALL
-Java_com_google_android_filament_Engine_nGetSupportedFeatureLevel(JNIEnv *, jclass,
-        jlong nativeEngine) {
-    Engine* engine = (Engine*) nativeEngine;
-    return (jint)engine->getSupportedFeatureLevel();
-}
-
-extern "C" JNIEXPORT jint JNICALL
-Java_com_google_android_filament_Engine_nSetActiveFeatureLevel(JNIEnv *, jclass,
-        jlong nativeEngine, jint ordinal) {
-    Engine* engine = (Engine*) nativeEngine;
-    return (jint)engine->setActiveFeatureLevel((Engine::FeatureLevel)ordinal);
-}
-
-extern "C" JNIEXPORT jint JNICALL
-Java_com_google_android_filament_Engine_nGetActiveFeatureLevel(JNIEnv *, jclass,
-        jlong nativeEngine) {
-    Engine* engine = (Engine*) nativeEngine;
-    return (jint)engine->getActiveFeatureLevel();
-}
-
-extern "C"
-JNIEXPORT jboolean JNICALL
-Java_com_google_android_filament_Engine_nHasFeatureFlag(JNIEnv *env, jclass clazz,
-        jlong nativeEngine, jstring name_) {
-    Engine* engine = (Engine*) nativeEngine;
-    const char *name = env->GetStringUTFChars(name_, 0);
-    std::optional<bool> result = engine->getFeatureFlag(name);
-    env->ReleaseStringUTFChars(name_, name);
-    return result.has_value();
-}
-extern "C"
-JNIEXPORT jboolean JNICALL
-Java_com_google_android_filament_Engine_nSetFeatureFlag(JNIEnv *env, jclass clazz,
-        jlong nativeEngine, jstring name_, jboolean value) {
-    Engine* engine = (Engine*) nativeEngine;
-    const char *name = env->GetStringUTFChars(name_, 0);
-    jboolean result = engine->setFeatureFlag(name, (bool)value);
-    env->ReleaseStringUTFChars(name_, name);
-    return result;
-}
-extern "C"
-JNIEXPORT jboolean JNICALL
-Java_com_google_android_filament_Engine_nGetFeatureFlag(JNIEnv *env, jclass clazz,
-        jlong nativeEngine, jstring name_) {
-    Engine* engine = (Engine*) nativeEngine;
-    const char *name = env->GetStringUTFChars(name_, 0);
-    std::optional<bool> result = engine->getFeatureFlag(name);
-    env->ReleaseStringUTFChars(name_, name);
-    return result.value_or(false); // we should never fail here
-}
-
-extern "C" JNIEXPORT jlong JNICALL Java_com_google_android_filament_Engine_nCreateBuilder(JNIEnv*,
-        jclass) {
-    Engine::Builder* builder = new Engine::Builder{};
-    return (jlong) builder;
-}
-
-extern "C" JNIEXPORT void JNICALL Java_com_google_android_filament_Engine_nDestroyBuilder(JNIEnv*,
-        jclass, jlong nativeBuilder) {
-    Engine::Builder* builder = (Engine::Builder*) nativeBuilder;
-    delete builder;
-}
-
-extern "C" JNIEXPORT void JNICALL Java_com_google_android_filament_Engine_nSetBuilderBackend(
-        JNIEnv*, jclass, jlong nativeBuilder, jlong backend) {
-    Engine::Builder* builder = (Engine::Builder*) nativeBuilder;
-    builder->backend((Engine::Backend) backend);
-}
-
-extern "C" JNIEXPORT void JNICALL Java_com_google_android_filament_Engine_nSetBuilderConfig(JNIEnv*,
-        jclass, jlong nativeBuilder, jlong commandBufferSizeMB, jlong perRenderPassArenaSizeMB,
-        jlong driverHandleArenaSizeMB, jlong minCommandBufferSizeMB, jlong perFrameCommandsSizeMB,
-        jlong jobSystemThreadCount, jboolean disableParallelShaderCompile,
-        jint stereoscopicType, jlong stereoscopicEyeCount,
-        jlong resourceAllocatorCacheSizeMB, jlong resourceAllocatorCacheMaxAge,
-        jboolean disableHandleUseAfterFreeCheck,
-        jint preferredShaderLanguage,
-        jboolean forceGLES2Context, jboolean assertNativeWindowIsValid) {
-    Engine::Builder* builder = (Engine::Builder*) nativeBuilder;
-    Engine::Config config = {
-            .commandBufferSizeMB = (uint32_t) commandBufferSizeMB,
-            .perRenderPassArenaSizeMB = (uint32_t) perRenderPassArenaSizeMB,
-            .driverHandleArenaSizeMB = (uint32_t) driverHandleArenaSizeMB,
-            .minCommandBufferSizeMB = (uint32_t) minCommandBufferSizeMB,
-            .perFrameCommandsSizeMB = (uint32_t) perFrameCommandsSizeMB,
-            .jobSystemThreadCount = (uint32_t) jobSystemThreadCount,
-            .disableParallelShaderCompile = (bool) disableParallelShaderCompile,
-            .stereoscopicType = (Engine::StereoscopicType) stereoscopicType,
-            .stereoscopicEyeCount = (uint8_t) stereoscopicEyeCount,
-            .resourceAllocatorCacheSizeMB = (uint32_t) resourceAllocatorCacheSizeMB,
-            .resourceAllocatorCacheMaxAge = (uint8_t) resourceAllocatorCacheMaxAge,
-            .disableHandleUseAfterFreeCheck = (bool) disableHandleUseAfterFreeCheck,
-            .preferredShaderLanguage = (Engine::Config::ShaderLanguage) preferredShaderLanguage,
-            .forceGLES2Context = (bool) forceGLES2Context,
-            .assertNativeWindowIsValid = (bool) assertNativeWindowIsValid,
-    };
-    builder->config(&config);
-}
-
-extern "C" JNIEXPORT void JNICALL Java_com_google_android_filament_Engine_nSetBuilderFeatureLevel(
-        JNIEnv*, jclass, jlong nativeBuilder, jint ordinal) {
-    Engine::Builder* builder = (Engine::Builder*) nativeBuilder;
-    builder->featureLevel((Engine::FeatureLevel)ordinal);
-}
-
-extern "C" JNIEXPORT void JNICALL Java_com_google_android_filament_Engine_nSetBuilderSharedContext(
-        JNIEnv*, jclass, jlong nativeBuilder, jlong sharedContext) {
-    Engine::Builder* builder = (Engine::Builder*) nativeBuilder;
-    builder->sharedContext((void*) sharedContext);
-}
-
-extern "C" JNIEXPORT void JNICALL Java_com_google_android_filament_Engine_nSetBuilderPaused(
-        JNIEnv*, jclass, jlong nativeBuilder, jboolean paused) {
-    Engine::Builder* builder = (Engine::Builder*) nativeBuilder;
-    builder->paused((bool) paused);
-}
-
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_google_android_filament_Engine_nSetBuilderFeature(JNIEnv *env, jclass clazz,
-        jlong nativeBuilder, jstring name_, jboolean value) {
-    Engine::Builder* builder = (Engine::Builder*) nativeBuilder;
-    const char *name = env->GetStringUTFChars(name_, 0);
-    builder->feature(name, (bool)value);
-    env->ReleaseStringUTFChars(name_, name);
-}
-
-extern "C" JNIEXPORT jlong JNICALL
-Java_com_google_android_filament_Engine_nBuilderBuild(JNIEnv*, jclass, jlong nativeBuilder) {
-    Engine::Builder* builder = (Engine::Builder*) nativeBuilder;
-    return (jlong) builder->build();
-}
-
-extern "C"
-JNIEXPORT jlong JNICALL
-Java_com_google_android_filament_Engine_getSteadyClockTimeNano(JNIEnv *env, jclass clazz) {
-    return (jlong)Engine::getSteadyClockTimeNano();
-}

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

@@ -38,7 +38,7 @@ Java_com_google_android_filament_EntityManager_nCreateArray(JNIEnv* env, jclass,
     // (which it is), but still.
     em->create((size_t) n, reinterpret_cast<Entity *>(entities));
 
-    env->ReleaseIntArrayElements(entities_, entities, JNI_ABORT);
+    env->ReleaseIntArrayElements(entities_, entities, 0);
 }
 
 extern "C" JNIEXPORT jint JNICALL

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

@@ -16,7 +16,9 @@
 
 #include <jni.h>
 
-#include "private/backend/VirtualMachineEnv.h"
+namespace filament {
+    extern jint JNI_OnLoad(JavaVM* vm, void* reserved);
+};
 
 JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
     JNIEnv* env;
@@ -24,9 +26,9 @@ JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
         return -1;
     }
 
-    // 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);
+#if ANDROID
+    ::filament::JNI_OnLoad(vm, reserved);
+#endif
 
     return JNI_VERSION_1_6;
 }

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

@@ -91,8 +91,7 @@ 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,
-            callback->getHandler(), &JniBufferCallback::postToJavaAndDestroy, callback);
+    BufferDescriptor desc(data, sizeInBytes, &JniBufferCallback::invoke, callback);
 
     indexBuffer->setBuffer(*engine, std::move(desc), (uint32_t) destOffsetInBytes);
 

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

@@ -76,11 +76,8 @@ 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 lispsm,
-        jfloat polygonOffsetConstant, jfloat polygonOffsetSlope,
-        jboolean screenSpaceContactShadows, jint stepCount,
-        jfloat maxShadowDistance, jboolean elvsm, jfloat blurWidth, jfloat shadowBulbRadius,
-        jfloatArray transform) {
+        jfloat shadowFarHint, jboolean stable, jboolean screenSpaceContactShadows, jint stepCount,
+        jfloat maxShadowDistance, jint vsmMsaaSamples) {
     LightManager::Builder *builder = (LightManager::Builder *) nativeBuilder;
     LightManager::ShadowOptions shadowOptions {
             .mapSize = (uint32_t)mapSize,
@@ -91,30 +88,19 @@ Java_com_google_android_filament_LightManager_nBuilderShadowOptions(JNIEnv* env,
             .shadowNearHint = shadowNearHint,
             .shadowFarHint = shadowFarHint,
             .stable = (bool)stable,
-            .lispsm = (bool)lispsm,
-            .polygonOffsetConstant = polygonOffsetConstant,
-            .polygonOffsetSlope = polygonOffsetConstant,
             .screenSpaceContactShadows = (bool)screenSpaceContactShadows,
             .stepCount = uint8_t(stepCount),
             .maxShadowDistance = maxShadowDistance,
             .vsm = {
-                    .elvsm = (bool)elvsm,
-                    .blurWidth = blurWidth
-            },
-            .shadowBulbRadius = shadowBulbRadius
+                    .msaaSamples = (uint8_t) vsmMsaaSamples
+            }
     };
-
     jfloat *nativeSplits = env->GetFloatArrayElements(splitPositions, NULL);
     const jsize splitCount = std::min((jsize) 3, env->GetArrayLength(splitPositions));
-    std::copy_n(nativeSplits, splitCount, shadowOptions.cascadeSplitPositions);
+    for (jsize i = 0; i < splitCount; i++) {
+        shadowOptions.cascadeSplitPositions[i] = nativeSplits[i];
+    }
     env->ReleaseFloatArrayElements(splitPositions, nativeSplits, 0);
-
-    jfloat* nativeTransform = env->GetFloatArrayElements(transform, NULL);
-    std::copy_n(nativeTransform,
-                std::min(4, env->GetArrayLength(transform)),
-                shadowOptions.transform.xyzw.v);
-    env->ReleaseFloatArrayElements(transform, nativeTransform, 0);
-
     builder->shadowOptions(shadowOptions);
 }
 
@@ -202,23 +188,6 @@ 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) {
@@ -243,7 +212,13 @@ 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,
@@ -404,31 +379,3 @@ 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

@@ -19,23 +19,17 @@
 #include <filament/Material.h>
 
 #include "common/NioUtils.h"
-#include "common/CallbackUtils.h"
 
 using namespace filament;
 
 extern "C" JNIEXPORT jlong JNICALL
 Java_com_google_android_filament_Material_nBuilderBuild(JNIEnv *env, jclass,
-        jlong nativeEngine, jobject buffer_, jint size, jint shBandCount) {
+        jlong nativeEngine, jobject buffer_, jint size) {
     Engine* engine = (Engine*) nativeEngine;
     AutoBuffer buffer(env, buffer_, size);
-    auto builder = Material::Builder();
-    if (shBandCount) {
-        builder.sphericalHarmonicsBandCount(shBandCount);
-    }
-    Material* material = builder
+    Material* material = Material::Builder()
             .package(buffer.getData(), buffer.getSize())
             .build(*engine);
-
     return (jlong) material;
 }
 
@@ -111,22 +105,6 @@ Java_com_google_android_filament_Material_nGetRefractionType(JNIEnv*, jclass,
     return (jint) material->getRefractionType();
 }
 
-extern "C"
-JNIEXPORT jint JNICALL
-Java_com_google_android_filament_Material_nGetReflectionMode(JNIEnv*, jclass,
-        jlong nativeMaterial) {
-    Material* material = (Material*) nativeMaterial;
-    return (jint) material->getReflectionMode();
-}
-
-extern "C"
-JNIEXPORT jint JNICALL
-Java_com_google_android_filament_Material_nGetFeatureLevel(JNIEnv*, jclass,
-        jlong nativeMaterial) {
-    Material* material = (Material*) nativeMaterial;
-    return (jint) material->getFeatureLevel();
-}
-
 extern "C"
 JNIEXPORT jint JNICALL
 Java_com_google_android_filament_Material_nGetVertexDomain(JNIEnv*, jclass,
@@ -175,14 +153,6 @@ Java_com_google_android_filament_Material_nIsDoubleSided(JNIEnv*, jclass,
     return (jboolean) material->isDoubleSided();
 }
 
-extern "C"
-JNIEXPORT jboolean JNICALL
-Java_com_google_android_filament_Material_nIsAlphaToCoverageEnabled(JNIEnv*, jclass,
-        jlong nativeMaterial) {
-    Material* material = (Material*) nativeMaterial;
-    return (jboolean) material->isAlphaToCoverageEnabled();
-}
-
 extern "C"
 JNIEXPORT jfloat JNICALL
 Java_com_google_android_filament_Material_nGetMaskThreshold(JNIEnv*, jclass,
@@ -277,17 +247,3 @@ Java_com_google_android_filament_Material_nHasParameter(JNIEnv* env, jclass,
     env->ReleaseStringUTFChars(name_, name);
     return (jboolean) hasParameter;
 }
-
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_google_android_filament_Material_nCompile(JNIEnv *env, jclass clazz,
-        jlong nativeMaterial, jint priority, jint variants, jobject handler, jobject runnable) {
-    Material* material = (Material*) nativeMaterial;
-    JniCallback* jniCallback = JniCallback::make(env, handler, runnable);
-    material->compile(
-            (Material::CompilerPriorityQueue) priority,
-            (UserVariantFilterBit) variants,
-            jniCallback->getHandler(), [jniCallback](Material*){
-                JniCallback::postToJavaAndDestroy(jniCallback);
-            });
-}

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

@@ -205,7 +205,7 @@ Java_com_google_android_filament_MaterialInstance_nSetIntParameterArray(JNIEnv *
             break;
     }
 
-    env->ReleaseIntArrayElements(v_, v, JNI_ABORT);
+    env->ReleaseIntArrayElements(v_, v, 0);
 
     env->ReleaseStringUTFChars(name_, name);
 }
@@ -246,21 +246,17 @@ Java_com_google_android_filament_MaterialInstance_nSetFloatParameterArray(JNIEnv
     env->ReleaseStringUTFChars(name_, name);
 }
 
-// defined in TextureSampler.cpp
-namespace filament::JniUtils {
-    TextureSampler from_long(jlong params) noexcept;
-} // TextureSamplerJniUtils
-
 extern "C"
 JNIEXPORT void JNICALL
 Java_com_google_android_filament_MaterialInstance_nSetParameterTexture(
         JNIEnv *env, jclass, jlong nativeMaterialInstance, jstring name_,
-        jlong nativeTexture, jlong sampler_) {
+        jlong nativeTexture, jint sampler_) {
     MaterialInstance* instance = (MaterialInstance*) nativeMaterialInstance;
     Texture* texture = (Texture*) nativeTexture;
+    TextureSampler& sampler = reinterpret_cast<TextureSampler&>(sampler_);
 
     const char *name = env->GetStringUTFChars(name_, 0);
-    instance->setParameter(name, texture, JniUtils::from_long(sampler_));
+    instance->setParameter(name, texture, sampler);
     env->ReleaseStringUTFChars(name_, name);
 }
 
@@ -345,14 +341,6 @@ Java_com_google_android_filament_MaterialInstance_nSetDepthWrite(JNIEnv*,
     instance->setDepthWrite(enable);
 }
 
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_google_android_filament_MaterialInstance_nSetStencilWrite(JNIEnv*, jclass,
-        jlong nativeMaterialInstance, jboolean enable) {
-    MaterialInstance* instance = (MaterialInstance*) nativeMaterialInstance;
-    instance->setStencilWrite(enable);
-}
-
 extern "C"
 JNIEXPORT void JNICALL
 Java_com_google_android_filament_MaterialInstance_nSetDepthCulling(JNIEnv*,
@@ -361,78 +349,6 @@ Java_com_google_android_filament_MaterialInstance_nSetDepthCulling(JNIEnv*,
     instance->setDepthCulling(enable);
 }
 
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_google_android_filament_MaterialInstance_nSetDepthFunc(JNIEnv*,
-        jclass, jlong nativeMaterialInstance, jlong function) {
-    MaterialInstance* instance = (MaterialInstance*) nativeMaterialInstance;
-    instance->setDepthFunc(static_cast<MaterialInstance::DepthFunc>(function));
-}
-
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_google_android_filament_MaterialInstance_nSetStencilCompareFunction(JNIEnv*, jclass,
-        jlong nativeMaterialInstance, jlong function, jlong face) {
-    MaterialInstance* instance = (MaterialInstance*) nativeMaterialInstance;
-    instance->setStencilCompareFunction(
-            static_cast<MaterialInstance::StencilCompareFunc>(function),
-            static_cast<MaterialInstance::StencilFace>(face));
-}
-
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_google_android_filament_MaterialInstance_nSetStencilOpStencilFail(JNIEnv*, jclass,
-        jlong nativeMaterialInstance, jlong op, jlong face) {
-    MaterialInstance* instance = (MaterialInstance*) nativeMaterialInstance;
-    instance->setStencilOpStencilFail(
-            static_cast<MaterialInstance::StencilOperation>(op),
-            static_cast<MaterialInstance::StencilFace>(face));
-}
-
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_google_android_filament_MaterialInstance_nSetStencilOpDepthFail(JNIEnv*, jclass,
-        jlong nativeMaterialInstance, jlong op, jlong face) {
-    MaterialInstance* instance = (MaterialInstance*) nativeMaterialInstance;
-    instance->setStencilOpDepthFail(
-            static_cast<MaterialInstance::StencilOperation>(op),
-            static_cast<MaterialInstance::StencilFace>(face));
-}
-
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_google_android_filament_MaterialInstance_nSetStencilOpDepthStencilPass(JNIEnv*, jclass,
-        jlong nativeMaterialInstance, jlong op, jlong face) {
-    MaterialInstance* instance = (MaterialInstance*) nativeMaterialInstance;
-    instance->setStencilOpDepthStencilPass(
-            static_cast<MaterialInstance::StencilOperation>(op),
-            static_cast<MaterialInstance::StencilFace>(face));
-}
-
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_google_android_filament_MaterialInstance_nSetStencilReferenceValue(JNIEnv*, jclass,
-        jlong nativeMaterialInstance, jint value, jlong face) {
-    MaterialInstance* instance = (MaterialInstance*) nativeMaterialInstance;
-    instance->setStencilReferenceValue(value, static_cast<MaterialInstance::StencilFace>(face));
-}
-
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_google_android_filament_MaterialInstance_nSetStencilReadMask(JNIEnv*, jclass,
-        jlong nativeMaterialInstance, jint readMask, jlong face) {
-    MaterialInstance* instance = (MaterialInstance*) nativeMaterialInstance;
-    instance->setStencilReadMask(readMask, static_cast<MaterialInstance::StencilFace>(face));
-}
-
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_google_android_filament_MaterialInstance_nSetStencilWriteMask(JNIEnv*, jclass,
-        jlong nativeMaterialInstance, jint writeMask, jlong face) {
-    MaterialInstance* instance = (MaterialInstance*) nativeMaterialInstance;
-    instance->setStencilWriteMask(writeMask, static_cast<MaterialInstance::StencilFace>(face));
-}
-
 extern "C"
 JNIEXPORT jstring JNICALL
 Java_com_google_android_filament_MaterialInstance_nGetName(JNIEnv* env, jclass,
@@ -448,99 +364,3 @@ 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;
-}
-
-extern "C"
-JNIEXPORT jfloat JNICALL
-Java_com_google_android_filament_MaterialInstance_nGetMaskThreshold(JNIEnv* env, jclass clazz,
-        jlong nativeMaterialInstance) {
-    MaterialInstance* instance = (MaterialInstance*)nativeMaterialInstance;
-    return instance->getMaskThreshold();
-}
-
-extern "C"
-JNIEXPORT jfloat JNICALL
-Java_com_google_android_filament_MaterialInstance_nGetSpecularAntiAliasingVariance(JNIEnv* env,
-        jclass clazz, jlong nativeMaterialInstance) {
-    MaterialInstance* instance = (MaterialInstance*)nativeMaterialInstance;
-    return instance->getSpecularAntiAliasingVariance();
-}
-
-extern "C"
-JNIEXPORT jfloat JNICALL
-Java_com_google_android_filament_MaterialInstance_nGetSpecularAntiAliasingThreshold(JNIEnv* env,
-        jclass clazz, jlong nativeMaterialInstance) {
-    MaterialInstance* instance = (MaterialInstance*)nativeMaterialInstance;
-    return instance->getSpecularAntiAliasingThreshold();
-}
-
-extern "C"
-JNIEXPORT jboolean JNICALL
-Java_com_google_android_filament_MaterialInstance_nIsDoubleSided(JNIEnv* env, jclass clazz,
-        jlong nativeMaterialInstance) {
-    MaterialInstance* instance = (MaterialInstance*)nativeMaterialInstance;
-    return instance->isDoubleSided();
-}
-
-extern "C"
-JNIEXPORT jint JNICALL
-Java_com_google_android_filament_MaterialInstance_nGetCullingMode(JNIEnv* env, jclass clazz,
-        jlong nativeMaterialInstance) {
-    MaterialInstance* instance = (MaterialInstance*)nativeMaterialInstance;
-    return (jint)instance->getCullingMode();
-}
-
-extern "C"
-JNIEXPORT jboolean JNICALL
-Java_com_google_android_filament_MaterialInstance_nIsColorWriteEnabled(JNIEnv* env, jclass clazz,
-        jlong nativeMaterialInstance) {
-    MaterialInstance* instance = (MaterialInstance*)nativeMaterialInstance;
-    return instance->isColorWriteEnabled();
-}
-
-extern "C"
-JNIEXPORT jboolean JNICALL
-Java_com_google_android_filament_MaterialInstance_nIsDepthWriteEnabled(JNIEnv* env, jclass clazz,
-        jlong nativeMaterialInstance) {
-    MaterialInstance* instance = (MaterialInstance*)nativeMaterialInstance;
-    return instance->isDepthWriteEnabled();
-}
-
-extern "C"
-JNIEXPORT jboolean JNICALL
-Java_com_google_android_filament_MaterialInstance_nIsStencilWriteEnabled(JNIEnv* env, jclass clazz,
-        jlong nativeMaterialInstance) {
-    MaterialInstance* instance = (MaterialInstance*)nativeMaterialInstance;
-    return instance->isStencilWriteEnabled();
-}
-
-extern "C"
-JNIEXPORT jboolean JNICALL
-Java_com_google_android_filament_MaterialInstance_nIsDepthCullingEnabled(JNIEnv* env, jclass clazz,
-        jlong nativeMaterialInstance) {
-    MaterialInstance* instance = (MaterialInstance*)nativeMaterialInstance;
-    return instance->isDepthCullingEnabled();
-}
-
-extern "C"
-JNIEXPORT jint JNICALL
-Java_com_google_android_filament_MaterialInstance_nGetDepthFunc(JNIEnv* env, jclass clazz,
-        jlong nativeMaterialInstance) {
-    MaterialInstance* instance = (MaterialInstance*)nativeMaterialInstance;
-    return (jint)instance->getDepthFunc();
-}

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

@@ -1,114 +0,0 @@
-/*
- * 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/MorphTargetBuffer.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_MorphTargetBuffer_nCreateBuilder(JNIEnv*, jclass) {
-    return (jlong) new MorphTargetBuffer::Builder();
-}
-
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_google_android_filament_MorphTargetBuffer_nDestroyBuilder(JNIEnv*, jclass,
-        jlong nativeBuilder) {
-    MorphTargetBuffer::Builder* builder = (MorphTargetBuffer::Builder *) nativeBuilder;
-    delete builder;
-}
-
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_google_android_filament_MorphTargetBuffer_nBuilderVertexCount(JNIEnv*, jclass,
-        jlong nativeBuilder, jint vertexCount) {
-    MorphTargetBuffer::Builder* builder = (MorphTargetBuffer::Builder *) nativeBuilder;
-    builder->vertexCount((size_t) vertexCount);
-}
-
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_google_android_filament_MorphTargetBuffer_nBuilderCount(JNIEnv*, jclass,
-        jlong nativeBuilder, jint count) {
-    MorphTargetBuffer::Builder* builder = (MorphTargetBuffer::Builder *) nativeBuilder;
-    builder->count((size_t) count);
-}
-
-extern "C"
-JNIEXPORT jlong JNICALL
-Java_com_google_android_filament_MorphTargetBuffer_nBuilderBuild(JNIEnv*, jclass,
-        jlong nativeBuilder, jlong nativeEngine) {
-    MorphTargetBuffer::Builder* builder = (MorphTargetBuffer::Builder *) nativeBuilder;
-    Engine *engine = (Engine *) nativeEngine;
-    return (jlong) builder->build(*engine);
-}
-
-// ------------------------------------------------------------------------------------------------
-
-extern "C"
-JNIEXPORT jint JNICALL
-Java_com_google_android_filament_MorphTargetBuffer_nSetPositionsAt(JNIEnv* env, jclass,
-        jlong nativeObject, jlong nativeEngine,
-        jint targetIndex, jfloatArray positions, jint count) {
-    MorphTargetBuffer *morphTargetBuffer = (MorphTargetBuffer *) nativeObject;
-    Engine *engine = (Engine *) nativeEngine;
-    jfloat* data = env->GetFloatArrayElements(positions, NULL);
-    morphTargetBuffer->setPositionsAt(*engine, targetIndex,
-            (math::float4*) data, size_t(count));
-    env->ReleaseFloatArrayElements(positions, data, JNI_ABORT);
-    return 0;
-}
-
-extern "C"
-JNIEXPORT jint JNICALL
-Java_com_google_android_filament_MorphTargetBuffer_nSetTangentsAt(JNIEnv* env, jclass,
-        jlong nativeObject, jlong nativeEngine,
-        jint targetIndex, jshortArray tangents, jint count) {
-    MorphTargetBuffer *morphTargetBuffer = (MorphTargetBuffer *) nativeObject;
-    Engine *engine = (Engine *) nativeEngine;
-    jshort* data = env->GetShortArrayElements(tangents, NULL);
-    morphTargetBuffer->setTangentsAt(*engine, targetIndex,
-            (math::short4*) data, size_t(count));
-    env->ReleaseShortArrayElements(tangents, data, JNI_ABORT);
-    return 0;
-}
-
-extern "C"
-JNIEXPORT jint JNICALL
-Java_com_google_android_filament_MorphTargetBuffer_nGetVertexCount(JNIEnv*, jclass,
-        jlong nativeObject) {
-    MorphTargetBuffer *morphTargetBuffer = (MorphTargetBuffer *) nativeObject;
-    return (jint)morphTargetBuffer->getVertexCount();
-}
-
-extern "C"
-JNIEXPORT jint JNICALL
-Java_com_google_android_filament_MorphTargetBuffer_nGetCount(JNIEnv*, jclass,
-        jlong nativeObject) {
-    MorphTargetBuffer *morphTargetBuffer = (MorphTargetBuffer *) nativeObject;
-    return (jint)morphTargetBuffer->getCount();
-}

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

@@ -104,14 +104,6 @@ Java_com_google_android_filament_RenderableManager_nBuilderGeometry__JIIJJIIII(J
             (size_t) count);
 }
 
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_google_android_filament_RenderableManager_nBuilderGeometryType(JNIEnv*, jclass,
-        jlong nativeBuilder, int type) {
-    RenderableManager::Builder *builder = (RenderableManager::Builder *) nativeBuilder;
-    builder->geometryType((RenderableManager::Builder::GeometryType)type);
-}
-
 extern "C"
 JNIEXPORT void JNICALL
 Java_com_google_android_filament_RenderableManager_nBuilderMaterial(JNIEnv*, jclass,
@@ -128,14 +120,6 @@ Java_com_google_android_filament_RenderableManager_nBuilderBlendOrder(JNIEnv*, j
     builder->blendOrder((size_t) index, (uint16_t) blendOrder);
 }
 
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_google_android_filament_RenderableManager_nBuilderGlobalBlendOrderEnabled(JNIEnv*, jclass,
-        jlong nativeBuilder, jint index, jboolean enabled) {
-    RenderableManager::Builder *builder = (RenderableManager::Builder *) nativeBuilder;
-    builder->globalBlendOrderEnabled((size_t) index, (bool) enabled);
-}
-
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_RenderableManager_nBuilderBoundingBox(JNIEnv*, jclass,
         jlong nativeBuilder, jfloat cx, jfloat cy, jfloat cz, jfloat ex, jfloat ey, jfloat ez) {
@@ -158,13 +142,6 @@ Java_com_google_android_filament_RenderableManager_nBuilderPriority(JNIEnv*, jcl
     builder->priority((uint8_t) priority);
 }
 
-extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_RenderableManager_nBuilderChannel(JNIEnv*, jclass,
-        jlong nativeBuilder, jint channel) {
-    RenderableManager::Builder *builder = (RenderableManager::Builder *) nativeBuilder;
-    builder->channel((uint8_t) channel);
-}
-
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_RenderableManager_nBuilderCulling(JNIEnv*, jclass,
         jlong nativeBuilder, jboolean enabled) {
@@ -193,14 +170,6 @@ 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) {
@@ -208,20 +177,6 @@ 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_nBuilderEnableSkinningBuffers(JNIEnv*, jclass,
-        jlong nativeBuilder, jboolean enabled) {
-    RenderableManager::Builder *builder = (RenderableManager::Builder *) nativeBuilder;
-    builder->enableSkinningBuffers(enabled);
-}
-
-extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_RenderableManager_nBuilderFog(JNIEnv*, jclass,
-        jlong nativeBuilder, jboolean enabled) {
-    RenderableManager::Builder *builder = (RenderableManager::Builder *) nativeBuilder;
-    builder->fog(enabled);
-}
-
 extern "C" JNIEXPORT jint JNICALL
 Java_com_google_android_filament_RenderableManager_nBuilderSkinningBones(JNIEnv* env, jclass,
         jlong nativeBuilder, jint boneCount, jobject bones, jint remaining) {
@@ -239,49 +194,11 @@ Java_com_google_android_filament_RenderableManager_nBuilderSkinningBones(JNIEnv*
 
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_RenderableManager_nBuilderMorphing(JNIEnv*, jclass,
-        jlong nativeBuilder, jint targetCount) {
+        jlong nativeBuilder, jboolean enabled) {
     RenderableManager::Builder *builder = (RenderableManager::Builder *) nativeBuilder;
-    builder->morphing(targetCount);
+    builder->morphing(enabled);
 }
 
-extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_RenderableManager_nBuilderMorphingStandard(JNIEnv*, jclass,
-        jlong nativeBuilder, jlong nativeMorphTargetBuffer) {
-    RenderableManager::Builder *builder = (RenderableManager::Builder *) nativeBuilder;
-    MorphTargetBuffer *morphTargetBuffer = (MorphTargetBuffer *) nativeMorphTargetBuffer;
-    builder->morphing(morphTargetBuffer);
-}
-
-extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_RenderableManager_nBuilderSetMorphTargetBufferOffsetAt(JNIEnv*, jclass,
-        jlong nativeBuilder, int level, int primitiveIndex, int offset) {
-    RenderableManager::Builder *builder = (RenderableManager::Builder *) nativeBuilder;
-    builder->morphing(level, primitiveIndex, offset);
-}
-
-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_nBuilderInstances(JNIEnv*, jclass,
-        jlong nativeBuilder, jint instanceCount) {
-    RenderableManager::Builder *builder = (RenderableManager::Builder *) nativeBuilder;
-    builder->instances(instanceCount);
-}
-
-// ------------------------------------------------------------------------------------------------
-
-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,
@@ -319,28 +236,12 @@ Java_com_google_android_filament_RenderableManager_nSetBonesAsQuaternions(JNIEnv
 
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_RenderableManager_nSetMorphWeights(JNIEnv* env, jclass,
-        jlong nativeRenderableManager, jint instance, jfloatArray weights, jint offset) {
+        jlong nativeRenderableManager, jint instance, jfloatArray weights) {
     RenderableManager *rm = (RenderableManager *) nativeRenderableManager;
     jfloat* vec = env->GetFloatArrayElements(weights, NULL);
-    jsize count = env->GetArrayLength(weights);
-    rm->setMorphWeights((RenderableManager::Instance)instance, vec, count, offset);
+    math::float4 floatvec(vec[0], vec[1], vec[2], vec[3]);
     env->ReleaseFloatArrayElements(weights, vec, JNI_ABORT);
-}
-
-extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_RenderableManager_nSetMorphTargetBufferOffsetAt(JNIEnv*,
-        jclass, jlong nativeRenderableManager, jint i, int level, jint primitiveIndex,
-        jlong, jint offset) {
-    RenderableManager *rm = (RenderableManager *) nativeRenderableManager;
-    rm->setMorphTargetBufferOffsetAt((RenderableManager::Instance) i, (uint8_t) level,
-            (size_t) primitiveIndex, (size_t) offset);
-}
-
-extern "C" JNIEXPORT jint JNICALL
-Java_com_google_android_filament_RenderableManager_nGetMorphTargetCount(JNIEnv* env, jclass,
-        jlong nativeRenderableManager, jint instance) {
-    RenderableManager *rm = (RenderableManager *) nativeRenderableManager;
-    return rm->getMorphTargetCount((RenderableManager::Instance)instance);
+    rm->setMorphWeights((RenderableManager::Instance)instance, floatvec);
 }
 
 extern "C" JNIEXPORT void JNICALL
@@ -366,13 +267,6 @@ Java_com_google_android_filament_RenderableManager_nSetPriority(JNIEnv*, jclass,
     rm->setPriority((RenderableManager::Instance) i, (uint8_t) priority);
 }
 
-extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_RenderableManager_nSetChannel(JNIEnv*, jclass,
-        jlong nativeRenderableManager, jint i, jint channel) {
-    RenderableManager *rm = (RenderableManager *) nativeRenderableManager;
-    rm->setChannel((RenderableManager::Instance) i, (uint8_t) channel);
-}
-
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_RenderableManager_nSetCulling(JNIEnv*, jclass,
         jlong nativeRenderableManager, jint i, jboolean enabled) {
@@ -380,20 +274,6 @@ Java_com_google_android_filament_RenderableManager_nSetCulling(JNIEnv*, jclass,
     rm->setCulling((RenderableManager::Instance) i, enabled);
 }
 
-extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_RenderableManager_nSetFogEnabled(JNIEnv*, jclass,
-        jlong nativeRenderableManager, jint i, jboolean enabled) {
-    RenderableManager *rm = (RenderableManager *) nativeRenderableManager;
-    rm->setFogEnabled((RenderableManager::Instance) i, enabled);
-}
-
-extern "C" JNIEXPORT jboolean JNICALL
-Java_com_google_android_filament_RenderableManager_nGetFogEnabled(JNIEnv*, jclass,
-        jlong nativeRenderableManager, jint i) {
-    RenderableManager *rm = (RenderableManager *) nativeRenderableManager;
-    return (jboolean)rm->getFogEnabled((RenderableManager::Instance) i);
-}
-
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_RenderableManager_nSetCastShadows(JNIEnv*, jclass,
         jlong nativeRenderableManager, jint i, jboolean enabled) {
@@ -459,13 +339,21 @@ Java_com_google_android_filament_RenderableManager_nSetMaterialInstanceAt(JNIEnv
             materialInstance);
 }
 
-extern "C" JNIEXPORT jlong JNICALL
+extern "C" JNIEXPORT long 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,
@@ -478,6 +366,15 @@ Java_com_google_android_filament_RenderableManager_nSetGeometryAt__JIIIJJII(JNIE
             (size_t) offset, (size_t) count);
 }
 
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_RenderableManager_nSetGeometryAt__JIIIII(JNIEnv*, jclass,
+        jlong nativeRenderableManager, jint i, jint primitiveIndex, jint primitiveType, jint offset,
+        jint count) {
+    RenderableManager *rm = (RenderableManager *) nativeRenderableManager;
+    rm->setGeometryAt((RenderableManager::Instance) i, (size_t) primitiveIndex,
+            (RenderableManager::PrimitiveType) primitiveType, (size_t) offset, (size_t) count);
+}
+
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_RenderableManager_nSetBlendOrderAt(JNIEnv*, jclass,
         jlong nativeRenderableManager, jint i, jint primitiveIndex, jint blendOrder) {
@@ -486,14 +383,6 @@ Java_com_google_android_filament_RenderableManager_nSetBlendOrderAt(JNIEnv*, jcl
             (uint16_t) blendOrder);
 }
 
-extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_RenderableManager_nSetGlobalBlendOrderEnabledAt(JNIEnv*, jclass,
-        jlong nativeRenderableManager, jint i, jint primitiveIndex, jboolean enabled) {
-    RenderableManager *rm = (RenderableManager *) nativeRenderableManager;
-    rm->setGlobalBlendOrderEnabledAt((RenderableManager::Instance) i, (size_t) primitiveIndex,
-            (bool) enabled);
-}
-
 extern "C" JNIEXPORT jint JNICALL
 Java_com_google_android_filament_RenderableManager_nGetEnabledAttributesAt(JNIEnv*, jclass,
         jlong nativeRenderableManager, jint i, jint primitiveIndex) {
@@ -501,17 +390,3 @@ 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

@@ -28,14 +28,6 @@
 using namespace filament;
 using namespace backend;
 
-
-extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_Renderer_nSkipFrame(JNIEnv *, jclass, jlong nativeRenderer,
-        jlong vsyncSteadyClockTimeNano) {
-    Renderer *renderer = (Renderer *) nativeRenderer;
-    renderer->skipFrame(uint64_t(vsyncSteadyClockTimeNano));
-}
-
 extern "C" JNIEXPORT jboolean JNICALL
 Java_com_google_android_filament_Renderer_nBeginFrame(JNIEnv *, jclass, jlong nativeRenderer,
         jlong nativeSwapChain, jlong frameTimeNanos) {
@@ -58,14 +50,6 @@ 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,
@@ -105,8 +89,7 @@ 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,
-            callback->getHandler(), &JniBufferCallback::postToJavaAndDestroy, callback);
+            (uint32_t) stride, &JniBufferCallback::invoke, callback);
 
     renderer->readPixels(uint32_t(xoffset), uint32_t(yoffset), uint32_t(width), uint32_t(height),
             std::move(desc));
@@ -141,8 +124,7 @@ 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,
-            callback->getHandler(), &JniBufferCallback::postToJavaAndDestroy, callback);
+            (uint32_t) stride, &JniBufferCallback::invoke, callback);
 
     renderer->readPixels(renderTarget,
             uint32_t(xoffset), uint32_t(yoffset), uint32_t(width), uint32_t(height),
@@ -164,9 +146,12 @@ Java_com_google_android_filament_Renderer_nResetUserTime(JNIEnv*, jclass, jlong
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_Renderer_nSetDisplayInfo(JNIEnv*, jclass, jlong nativeRenderer, jfloat refreshRate) {
+Java_com_google_android_filament_Renderer_nSetDisplayInfo(JNIEnv*, jclass, jlong nativeRenderer,
+        jfloat refreshRate, jlong presentationDeadlineNanos, jlong vsyncOffsetNanos) {
     Renderer *renderer = (Renderer *) nativeRenderer;
-    renderer->setDisplayInfo({ .refreshRate = refreshRate });
+    renderer->setDisplayInfo({ .refreshRate = refreshRate,
+                               .presentationDeadlineNanos = (uint64_t)presentationDeadlineNanos,
+                               .vsyncOffsetNanos = (uint64_t)vsyncOffsetNanos });
 }
 
 extern "C" JNIEXPORT void JNICALL
@@ -188,17 +173,3 @@ Java_com_google_android_filament_Renderer_nSetClearOptions(JNIEnv *, jclass ,
                                 .clear = (bool) clear,
                                 .discard = (bool) discard});
 }
-
-extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_Renderer_nSetPresentationTime(JNIEnv *, jclass ,
-    jlong nativeRenderer, jlong monotonicClockNanos) {
-    Renderer *renderer = (Renderer *) nativeRenderer;
-    renderer->setPresentationTime(monotonicClockNanos);
-}
-
-extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_Renderer_nSetVsyncTime(JNIEnv *, jclass,
-    jlong nativeRenderer, jlong steadyClockTimeNano) {
-    Renderer *renderer = (Renderer *) nativeRenderer;
-    renderer->setVsyncTime(steadyClockTimeNano);
-}

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

@@ -71,13 +71,6 @@ Java_com_google_android_filament_Scene_nRemoveEntities(JNIEnv *env, jclass type,
     env->ReleaseIntArrayElements(entities, (jint*) nativeEntities, JNI_ABORT);
 }
 
-extern "C" JNIEXPORT jint JNICALL
-Java_com_google_android_filament_Scene_nGetEntityCount(JNIEnv *env, jclass type,
-        jlong nativeScene) {
-    Scene* scene = (Scene*) nativeScene;
-    return (jint) scene->getEntityCount();
-}
-
 extern "C" JNIEXPORT jint JNICALL
 Java_com_google_android_filament_Scene_nGetRenderableCount(JNIEnv *env, jclass type,
         jlong nativeScene) {
@@ -90,30 +83,3 @@ Java_com_google_android_filament_Scene_nGetLightCount(JNIEnv *env, jclass type,
     Scene* scene = (Scene*) nativeScene;
     return (jint) scene->getLightCount();
 }
-
-extern "C" JNIEXPORT jboolean JNICALL
-Java_com_google_android_filament_Scene_nHasEntity(JNIEnv *env, jclass type, jlong nativeScene,
-        jint entityId) {
-    Scene* scene = (Scene*) nativeScene;
-    Entity entity = Entity::import(entityId);
-    return (jboolean) scene->hasEntity(entity);
-}
-
-extern "C"
-JNIEXPORT jboolean JNICALL
-Java_com_google_android_filament_Scene_nGetEntities(JNIEnv *env, jclass ,
-        jlong nativeScene, jintArray outArray, jint length) {
-    Scene const* const scene = (Scene*) nativeScene;
-    if (length < scene->getEntityCount()) {
-        // should not happen because we already checked on the java side
-        return JNI_FALSE;
-    }
-    jint *out = (jint *) env->GetIntArrayElements(outArray, nullptr);
-    scene->forEach([out, length, i = 0](Entity entity)mutable {
-        if (i < length) { // this is just paranoia here
-            out[i++] = (jint) entity.getId();
-        }
-    });
-    env->ReleaseIntArrayElements(outArray, (jint*) out, 0);
-    return JNI_TRUE;
-}

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

@@ -1,116 +0,0 @@
-/*
- * 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_Skybox_nGetTexture(JNIEnv* env, jclass,
+Java_com_google_android_filament_Skybix_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>
@@ -98,6 +98,13 @@ Java_com_google_android_filament_Stream_nBuilderStreamSource(JNIEnv* env,
     builder->setStreamSource(env, streamSource);
 }
 
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_Stream_nBuilderStream(JNIEnv*, jclass,
+        jlong nativeStreamBuilder, jlong externalTextureId) {
+    StreamBuilder* builder = (StreamBuilder*) nativeStreamBuilder;
+    builder->builder()->stream(externalTextureId);
+}
+
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_Stream_nBuilderWidth(JNIEnv*, jclass,
         jlong nativeStreamBuilder, jint width) {
@@ -133,6 +140,40 @@ Java_com_google_android_filament_Stream_nSetDimensions(JNIEnv*, jclass, jlong na
     stream->setDimensions((uint32_t) width, (uint32_t) height);
 }
 
+extern "C" JNIEXPORT jint JNICALL
+Java_com_google_android_filament_Stream_nReadPixels(JNIEnv *env, jclass,
+        jlong nativeStream, jlong nativeEngine,
+        jint xoffset, jint yoffset, jint width, jint height,
+        jobject storage, jint remaining,
+        jint left, jint top, jint type, jint alignment, jint stride, jint format,
+        jobject handler, jobject runnable) {
+    Stream *stream = (Stream *) nativeStream;
+    Engine *engine = (Engine *) nativeEngine;
+
+    stride = stride ? stride : width;
+    size_t sizeInBytes = PixelBufferDescriptor::computeDataSize(
+            (PixelDataFormat) format, (PixelDataType) type,
+            (size_t) stride, (size_t) (height + top), (size_t) alignment);
+
+    AutoBuffer nioBuffer(env, storage, 0);
+    if (sizeInBytes > (remaining << nioBuffer.getShift())) {
+        // BufferOverflowException
+        return -1;
+    }
+
+    void *buffer = nioBuffer.getData();
+    auto *callback = JniBufferCallback::make(engine, env, handler, runnable, std::move(nioBuffer));
+
+    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);
+
+    stream->readPixels(uint32_t(xoffset), uint32_t(yoffset), uint32_t(width), uint32_t(height),
+            std::move(desc));
+
+    return 0;
+}
+
 extern "C" JNIEXPORT jlong JNICALL
 Java_com_google_android_filament_Stream_nGetTimestamp(JNIEnv*, jclass, jlong nativeStream) {
     Stream *stream = (Stream *) nativeStream;
@@ -145,7 +186,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)) {
@@ -156,8 +197,8 @@ Java_com_google_android_filament_Stream_nSetAcquiredImage(JNIEnv* env, jclass, j
          if (!AHardwareBuffer_fromHardwareBuffer_fn) {
             __android_log_print(ANDROID_LOG_WARN, "Filament", "AHardwareBuffer_fromHardwareBuffer is not available.");
             sHardwareBufferSupported = false;
-            return;
         }
+        return;
     }
 
     AHardwareBuffer* nativeBuffer = AHardwareBuffer_fromHardwareBuffer_fn(env, hwbuffer);
@@ -177,6 +218,5 @@ Java_com_google_android_filament_Stream_nSetAcquiredImage(JNIEnv* env, jclass, j
 
 #endif
 
-    stream->setAcquiredImage((void*) nativeBuffer,
-            callback->getHandler(), &JniImageCallback::postToJavaAndDestroy, callback);
+    stream->setAcquiredImage((void*) nativeBuffer, &JniImageCallback::invoke, callback);
 }

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

@@ -16,7 +16,6 @@
 
 #include <jni.h>
 
-#include <filament/Engine.h>
 #include <filament/SwapChain.h>
 
 #include "common/CallbackUtils.h"
@@ -27,22 +26,6 @@ extern "C" JNIEXPORT void JNICALL
 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(nullptr, [callback](SwapChain* swapChain) {
-        JniCallback::postToJavaAndDestroy(callback);
-    });
-}
-
-extern "C" JNIEXPORT jboolean JNICALL
-Java_com_google_android_filament_SwapChain_nIsSRGBSwapChainSupported(
-        JNIEnv *, jclass, jlong nativeEngine) {
-    Engine* engine = (Engine*) nativeEngine;
-    return (jboolean)SwapChain::isSRGBSwapChainSupported(*engine);
-}
-
-extern "C" JNIEXPORT jboolean JNICALL
-Java_com_google_android_filament_SwapChain_nIsProtectedContentSupported(
-        JNIEnv *, jclass, jlong nativeEngine) {
-    Engine* engine = (Engine*) nativeEngine;
-    return (jboolean)SwapChain::isProtectedContentSupported(*engine);
+    auto *callback = JniCallback::make(env, handler, runnable);
+    swapChain->setFrameCompletedCallback(&JniCallback::invoke, 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,8 +31,6 @@
 #include "common/CallbackUtils.h"
 #include "common/NioUtils.h"
 
-#include "private/backend/VirtualMachineEnv.h"
-
 using namespace filament;
 using namespace backend;
 
@@ -131,13 +129,6 @@ 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) {
@@ -188,6 +179,68 @@ Java_com_google_android_filament_Texture_nGetInternalFormat(JNIEnv*, jclass,
     return (jint) texture->getFormat();
 }
 
+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 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) height, (size_t) alignment);
+
+    AutoBuffer nioBuffer(env, storage, 0);
+    if (sizeInBytes > (size_t(remaining) << nioBuffer.getShift())) {
+        // BufferOverflowException
+        return -1;
+    }
+
+    void *buffer = nioBuffer.getData();
+    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) top,
+            (uint32_t) stride, &JniBufferCallback::invoke, callback);
+
+    texture->setImage(*engine, (size_t) level, (uint32_t) xoffset, (uint32_t) yoffset,
+            (uint32_t) width, (uint32_t) height, std::move(desc));
+
+    return 0;
+}
+
+extern "C" JNIEXPORT jint JNICALL
+Java_com_google_android_filament_Texture_nSetImageCompressed(JNIEnv *env, jclass,
+        jlong nativeTexture, jlong nativeEngine, jint level, jint xoffset, jint yoffset,
+        jint width, jint height, jobject storage,  jint remaining,
+        jint, jint, jint, jint, jint compressedSizeInBytes, jint compressedFormat,
+        jobject handler, jobject runnable) {
+    Texture *texture = (Texture *) nativeTexture;
+    Engine *engine = (Engine *) nativeEngine;
+
+    size_t sizeInBytes = (size_t) compressedSizeInBytes;
+
+    AutoBuffer nioBuffer(env, storage, 0);
+    if (sizeInBytes > (size_t(remaining) << nioBuffer.getShift())) {
+        // BufferOverflowException
+        return -1;
+    }
+
+    void *buffer = nioBuffer.getData();
+    auto *callback = JniBufferCallback::make(engine, env, handler, runnable, std::move(nioBuffer));
+
+    Texture::PixelBufferDescriptor desc(buffer, sizeInBytes,
+            (backend::CompressedPixelDataType) compressedFormat, (uint32_t) compressedSizeInBytes,
+            &JniBufferCallback::invoke, callback);
+
+    texture->setImage(*engine, (size_t) level, (uint32_t) xoffset, (uint32_t) yoffset,
+            (uint32_t) width, (uint32_t) height, std::move(desc));
+
+    return 0;
+}
+
 extern "C" JNIEXPORT jint JNICALL
 Java_com_google_android_filament_Texture_nSetImage3D(JNIEnv* env, jclass, jlong nativeTexture,
         jlong nativeEngine, jint level,
@@ -214,8 +267,7 @@ Java_com_google_android_filament_Texture_nSetImage3D(JNIEnv* env, jclass, jlong
 
     Texture::PixelBufferDescriptor desc(buffer, sizeInBytes, (backend::PixelDataFormat) format,
             (backend::PixelDataType) type, (uint8_t) alignment, (uint32_t) left, (uint32_t) top,
-            (uint32_t) stride,
-            callback->getHandler(), &JniBufferCallback::postToJavaAndDestroy, callback);
+            (uint32_t) stride, &JniBufferCallback::invoke, callback);
 
     texture->setImage(*engine, (size_t) level,
             (uint32_t) xoffset, (uint32_t) yoffset, (uint32_t) zoffset,
@@ -249,7 +301,7 @@ Java_com_google_android_filament_Texture_nSetImage3DCompressed(JNIEnv *env, jcla
 
     Texture::PixelBufferDescriptor desc(buffer, sizeInBytes,
             (backend::CompressedPixelDataType) compressedFormat, (uint32_t) compressedSizeInBytes,
-            callback->getHandler(), &JniBufferCallback::postToJavaAndDestroy, callback);
+            &JniBufferCallback::invoke, callback);
 
     texture->setImage(*engine, (size_t) level,
             (uint32_t) xoffset, (uint32_t) yoffset, (uint32_t) zoffset,
@@ -287,13 +339,9 @@ Java_com_google_android_filament_Texture_nSetImageCubemap(JNIEnv *env, jclass,
 
     Texture::PixelBufferDescriptor desc(buffer, sizeInBytes, (backend::PixelDataFormat) format,
             (backend::PixelDataType) type, (uint8_t) alignment, (uint32_t) left, (uint32_t) top,
-            (uint32_t) stride,
-            callback->getHandler(), &JniBufferCallback::postToJavaAndDestroy, callback);
+            (uint32_t) stride, &JniBufferCallback::invoke, callback);
 
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdeprecated-declarations"
     texture->setImage(*engine, (size_t) level, std::move(desc), faceOffsets);
-#pragma clang diagnostic pop
 
     return 0;
 }
@@ -326,12 +374,9 @@ Java_com_google_android_filament_Texture_nSetImageCubemapCompressed(JNIEnv *env,
 
     Texture::PixelBufferDescriptor desc(buffer, sizeInBytes,
             (backend::CompressedPixelDataType) compressedFormat, (uint32_t) compressedSizeInBytes,
-            callback->getHandler(), &JniBufferCallback::postToJavaAndDestroy, callback);
+            &JniBufferCallback::invoke, callback);
 
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdeprecated-declarations"
     texture->setImage(*engine, (size_t) level, std::move(desc), faceOffsets);
-#pragma clang diagnostic pop
 
     return 0;
 }
@@ -402,7 +447,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,
-            callback->getHandler(), &JniBufferCallback::postToJavaAndDestroy, callback);
+            &JniBufferCallback::invoke, callback);
 
     Texture::PrefilterOptions options;
     options.sampleCount = sampleCount;
@@ -416,7 +461,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
@@ -425,37 +470,46 @@ Java_com_google_android_filament_Texture_nGeneratePrefilterMipmap(JNIEnv *env, j
 #define BITMAP_CONFIG_RGBA_F16  4
 #define BITMAP_CONFIG_HARDWARE  5
 
-class AutoBitmap : public JniCallback {
-private:
-
+class AutoBitmap {
+public:
     AutoBitmap(JNIEnv* env, jobject bitmap) noexcept
-            : JniCallback(),
-              mBitmap(env->NewGlobalRef(bitmap)) {
+            : mEnv(env)
+            , mBitmap(env->NewGlobalRef(bitmap))
+    {
         if (mBitmap) {
-            AndroidBitmap_getInfo(env, mBitmap, &mInfo);
-            AndroidBitmap_lockPixels(env, mBitmap, &mData);
+            AndroidBitmap_getInfo(mEnv, mBitmap, &mInfo);
+            AndroidBitmap_lockPixels(mEnv, mBitmap, &mData);
         }
     }
 
     AutoBitmap(JNIEnv* env, jobject bitmap, jobject handler, jobject runnable) noexcept
-            : JniCallback(env, handler, runnable),
-              mBitmap(env->NewGlobalRef(bitmap)) {
+            : mEnv(env)
+            , mBitmap(env->NewGlobalRef(bitmap))
+            , mHandler(env->NewGlobalRef(handler))
+            , mCallback(env->NewGlobalRef(runnable))
+    {
+        acquireCallbackJni(env, mCallbackUtils);
         if (mBitmap) {
-            AndroidBitmap_getInfo(env, mBitmap, &mInfo);
-            AndroidBitmap_lockPixels(env, mBitmap, &mData);
+            AndroidBitmap_getInfo(mEnv, mBitmap, &mInfo);
+            AndroidBitmap_lockPixels(mEnv, mBitmap, &mData);
         }
     }
 
-    void release(JNIEnv* env) {
+    ~AutoBitmap() noexcept {
+        releaseCallbackJni(mEnv, mCallbackUtils, mHandler, mCallback);
         if (mBitmap) {
-            AndroidBitmap_unlockPixels(env, mBitmap);
-            env->DeleteGlobalRef(mBitmap);
+            AndroidBitmap_unlockPixels(mEnv, mBitmap);
+            mEnv->DeleteGlobalRef(mBitmap);
         }
     }
 
-    ~AutoBitmap() override = default;
+    AutoBitmap(AutoBitmap &&rhs) noexcept {
+        mEnv = rhs.mEnv;
+        std::swap(mData, rhs.mData);
+        std::swap(mBitmap, rhs.mBitmap);
+        std::swap(mInfo, rhs.mInfo);
+    }
 
-public:
     void* getData() const noexcept {
         return mData;
     }
@@ -482,37 +536,28 @@ public:
         }
     }
 
-    // create a AutoBitmap
-    static AutoBitmap* make(JNIEnv* env, jobject bitmap, jobject handler, jobject runnable) {
-        return new AutoBitmap(env, bitmap, handler, runnable);
+    static void invoke(void* buffer, size_t n, void* user) {
+        AutoBitmap* data = reinterpret_cast<AutoBitmap*>(user);
+        delete data;
     }
 
-    // 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) {
+    static AutoBitmap* make(Engine* engine, 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;
+    static AutoBitmap* make(Engine* engine, JNIEnv* env, jobject bitmap,
+            jobject handler, jobject runnable) {
+        return new AutoBitmap(env, bitmap, handler, runnable);
     }
 
 private:
+    JNIEnv* mEnv;
     void* mData = nullptr;
-    jobject mBitmap{};
-    AndroidBitmapInfo mInfo{};
+    jobject mBitmap = nullptr;
+    jobject mHandler = nullptr;
+    jobject mCallback = nullptr;
+    AndroidBitmapInfo mInfo;
+    CallbackJni mCallbackUtils;
 };
 
 extern "C"
@@ -523,14 +568,14 @@ Java_com_google_android_filament_android_TextureHelper_nSetBitmap(JNIEnv* env, j
     Texture* texture = (Texture*) nativeTexture;
     Engine *engine = (Engine *) nativeEngine;
 
-    auto* autoBitmap = AutoBitmap::make(env, bitmap);
+    auto* autoBitmap = AutoBitmap::make(engine, env, bitmap);
 
     Texture::PixelBufferDescriptor desc(
             autoBitmap->getData(),
             autoBitmap->getSizeInBytes(),
             autoBitmap->getFormat(format),
             autoBitmap->getType(format),
-            &AutoBitmap::invokeNoCallback, autoBitmap);
+            &AutoBitmap::invoke, autoBitmap);
 
     texture->setImage(*engine, (size_t) level,
             (uint32_t) xoffset, (uint32_t) yoffset,
@@ -546,14 +591,14 @@ Java_com_google_android_filament_android_TextureHelper_nSetBitmapWithCallback(JN
     Texture* texture = (Texture*) nativeTexture;
     Engine *engine = (Engine *) nativeEngine;
 
-    auto* autoBitmap = AutoBitmap::make(env, bitmap, handler, runnable);
+    auto* autoBitmap = AutoBitmap::make(engine, env, bitmap, handler, runnable);
 
     Texture::PixelBufferDescriptor desc(
             autoBitmap->getData(),
             autoBitmap->getSizeInBytes(),
             autoBitmap->getFormat(format),
             autoBitmap->getType(format),
-            autoBitmap->getHandler(), &AutoBitmap::invoke, autoBitmap);
+            &AutoBitmap::invoke, autoBitmap);
 
     texture->setImage(*engine, (size_t) level,
             (uint32_t) xoffset, (uint32_t) yoffset,

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

@@ -18,139 +18,142 @@
 
 #include <filament/TextureSampler.h>
 
-#include <utils/algorithm.h>
-
 using namespace filament;
 
-namespace filament::JniUtils {
-
-jlong to_long(TextureSampler const& sampler) noexcept {
-    return jlong(utils::bit_cast<uint32_t>(sampler.getSamplerParams()));
-}
-
-TextureSampler from_long(jlong params) noexcept {
-    return TextureSampler{
-            utils::bit_cast<backend::SamplerParams>(
-                    static_cast<uint32_t>(params))};
-}
-
-} // namespace filament::JniUtils
-
-using namespace JniUtils;
-
-extern "C" JNIEXPORT jlong JNICALL
-Java_com_google_android_filament_TextureSampler_nCreateSampler(JNIEnv *, jclass, jint min,
+extern "C" JNIEXPORT jint JNICALL
+Java_com_google_android_filament_TextureSampler_nCreateSampler(JNIEnv *env, jclass type, jint min,
         jint max, jint s, jint t, jint r) {
-    TextureSampler sampler(static_cast<TextureSampler::MinFilter>(min),
-                           static_cast<TextureSampler::MagFilter>(max),
-                           static_cast<TextureSampler::WrapMode>(s),
-                           static_cast<TextureSampler::WrapMode>(t),
-                           static_cast<TextureSampler::WrapMode>(r));
-    return to_long(sampler);
+    return TextureSampler(static_cast<TextureSampler::MinFilter>(min),
+            static_cast<TextureSampler::MagFilter>(max), static_cast<TextureSampler::WrapMode>(s),
+            static_cast<TextureSampler::WrapMode>(t),
+            static_cast<TextureSampler::WrapMode>(r)).getSamplerParams().u;
 }
 
-extern "C" JNIEXPORT jlong JNICALL
-Java_com_google_android_filament_TextureSampler_nCreateCompareSampler(JNIEnv *, jclass,
+extern "C" JNIEXPORT jint JNICALL
+Java_com_google_android_filament_TextureSampler_nCreateCompareSampler(JNIEnv *env, jclass type,
         jint mode, jint function) {
-    TextureSampler sampler(static_cast<TextureSampler::CompareMode>(mode),
-                           static_cast<TextureSampler::CompareFunc>(function));
-    return to_long(sampler);
+    return TextureSampler(static_cast<TextureSampler::CompareMode>(mode),
+            static_cast<TextureSampler::CompareFunc>(function)).getSamplerParams().u;
 }
 
 extern "C" JNIEXPORT jint JNICALL
-Java_com_google_android_filament_TextureSampler_nGetMinFilter(JNIEnv *, jclass, jlong sampler) {
-    return static_cast<jint>(from_long(sampler).getMinFilter());
+Java_com_google_android_filament_TextureSampler_nGetMinFilter(JNIEnv *env, jclass type,
+        jint sampler_) {
+    TextureSampler &sampler = reinterpret_cast<TextureSampler &>(sampler_);
+    return static_cast<jint>(sampler.getMinFilter());
 }
 
-extern "C" JNIEXPORT jlong JNICALL
-Java_com_google_android_filament_TextureSampler_nSetMinFilter(JNIEnv *, jclass, jlong sampler_, jint filter) {
-    TextureSampler sampler{from_long(sampler_)};
+extern "C" JNIEXPORT jint JNICALL
+Java_com_google_android_filament_TextureSampler_nSetMinFilter(JNIEnv *env, jclass type,
+        jint sampler_, jint filter) {
+    TextureSampler &sampler = reinterpret_cast<TextureSampler &>(sampler_);
     sampler.setMinFilter(static_cast<TextureSampler::MinFilter>(filter));
-    return to_long(sampler);
+    return sampler.getSamplerParams().u;
 }
 
 extern "C" JNIEXPORT jint JNICALL
-Java_com_google_android_filament_TextureSampler_nGetMagFilter(JNIEnv *, jclass, jlong sampler) {
-    return static_cast<jint>(from_long(sampler).getMagFilter());
+Java_com_google_android_filament_TextureSampler_nGetMagFilter(JNIEnv *env, jclass type,
+        jint sampler_) {
+    TextureSampler &sampler = reinterpret_cast<TextureSampler &>(sampler_);
+    return static_cast<jint>(sampler.getMagFilter());
 }
 
-extern "C" JNIEXPORT jlong JNICALL
-Java_com_google_android_filament_TextureSampler_nSetMagFilter(JNIEnv *, jclass, jlong sampler_, jint filter) {
-    TextureSampler sampler{from_long(sampler_)};
+extern "C" JNIEXPORT jint JNICALL
+Java_com_google_android_filament_TextureSampler_nSetMagFilter(JNIEnv *env, jclass type,
+        jint sampler_, jint filter) {
+    TextureSampler &sampler = reinterpret_cast<TextureSampler &>(sampler_);
     sampler.setMagFilter(static_cast<TextureSampler::MagFilter>(filter));
-    return to_long(sampler);
+    return sampler.getSamplerParams().u;
 }
 
 extern "C" JNIEXPORT jint JNICALL
-Java_com_google_android_filament_TextureSampler_nGetWrapModeS(JNIEnv *, jclass, jlong sampler) {
-    return static_cast<jint>(from_long(sampler).getWrapModeS());
+Java_com_google_android_filament_TextureSampler_nGetWrapModeS(JNIEnv *env, jclass type,
+        jint sampler_) {
+    TextureSampler &sampler = reinterpret_cast<TextureSampler &>(sampler_);
+    return static_cast<jint>(sampler.getWrapModeS());
 }
 
-extern "C" JNIEXPORT jlong JNICALL
-Java_com_google_android_filament_TextureSampler_nSetWrapModeS(JNIEnv *, jclass, jlong sampler_, jint mode) {
-    TextureSampler sampler{from_long(sampler_)};
+extern "C" JNIEXPORT jint JNICALL
+Java_com_google_android_filament_TextureSampler_nSetWrapModeS(JNIEnv *env, jclass type,
+        jint sampler_, jint mode) {
+    TextureSampler &sampler = reinterpret_cast<TextureSampler &>(sampler_);
     sampler.setWrapModeS(static_cast<TextureSampler::WrapMode>(mode));
-    return to_long(sampler);
+    return sampler.getSamplerParams().u;
 }
 
 extern "C" JNIEXPORT jint JNICALL
-Java_com_google_android_filament_TextureSampler_nGetWrapModeT(JNIEnv *, jclass, jlong sampler) {
-    return static_cast<jint>(from_long(sampler).getWrapModeT());
+Java_com_google_android_filament_TextureSampler_nGetWrapModeT(JNIEnv *env, jclass type,
+        jint sampler_) {
+    TextureSampler &sampler = reinterpret_cast<TextureSampler &>(sampler_);
+    return static_cast<jint>(sampler.getWrapModeT());
 }
 
-extern "C" JNIEXPORT jlong JNICALL
-Java_com_google_android_filament_TextureSampler_nSetWrapModeT(JNIEnv *, jclass, jlong sampler_, jint mode) {
-    TextureSampler sampler{from_long(sampler_)};
+extern "C" JNIEXPORT jint JNICALL
+Java_com_google_android_filament_TextureSampler_nSetWrapModeT(JNIEnv *env, jclass type,
+        jint sampler_, jint mode) {
+    TextureSampler &sampler = reinterpret_cast<TextureSampler &>(sampler_);
     sampler.setWrapModeT(static_cast<TextureSampler::WrapMode>(mode));
-    return to_long(sampler);
+    return sampler.getSamplerParams().u;
 }
 
 extern "C" JNIEXPORT jint JNICALL
-Java_com_google_android_filament_TextureSampler_nGetWrapModeR(JNIEnv *, jclass, jlong sampler) {
-    return static_cast<jint>(from_long(sampler).getWrapModeR());
+Java_com_google_android_filament_TextureSampler_nGetWrapModeR(JNIEnv *env, jclass type,
+        jint sampler_) {
+    TextureSampler &sampler = reinterpret_cast<TextureSampler &>(sampler_);
+    return static_cast<jint>(sampler.getWrapModeR());
 }
 
-extern "C" JNIEXPORT jlong JNICALL
-Java_com_google_android_filament_TextureSampler_nSetWrapModeR(JNIEnv *, jclass, jlong sampler_, jint mode) {
-    TextureSampler sampler{from_long(sampler_)};
+extern "C" JNIEXPORT jint JNICALL
+Java_com_google_android_filament_TextureSampler_nSetWrapModeR(JNIEnv *env, jclass type,
+        jint sampler_, jint mode) {
+    TextureSampler &sampler = reinterpret_cast<TextureSampler &>(sampler_);
     sampler.setWrapModeR(static_cast<TextureSampler::WrapMode>(mode));
-    return to_long(sampler);
+    return sampler.getSamplerParams().u;
 }
 
 extern "C" JNIEXPORT jint JNICALL
-Java_com_google_android_filament_TextureSampler_nGetCompareMode(JNIEnv *, jclass, jlong sampler) {
-    return static_cast<jint>(from_long(sampler).getCompareMode());
+Java_com_google_android_filament_TextureSampler_nGetCompareMode(JNIEnv *env, jclass type,
+        jint sampler_) {
+    TextureSampler &sampler = reinterpret_cast<TextureSampler &>(sampler_);
+    return static_cast<jint>(sampler.getCompareMode());
 }
 
-extern "C" JNIEXPORT jlong JNICALL
-Java_com_google_android_filament_TextureSampler_nSetCompareMode(JNIEnv *, jclass, jlong sampler_, jint mode) {
-    TextureSampler sampler{from_long(sampler_)};
+extern "C" JNIEXPORT jint JNICALL
+Java_com_google_android_filament_TextureSampler_nSetCompareMode(JNIEnv *env, jclass type,
+        jint sampler_, jint mode) {
+    TextureSampler &sampler = reinterpret_cast<TextureSampler &>(sampler_);
     sampler.setCompareMode(static_cast<TextureSampler::CompareMode>(mode),
             sampler.getCompareFunc());
-    return to_long(sampler);
+    return sampler.getSamplerParams().u;
 }
 
 extern "C" JNIEXPORT jint JNICALL
-Java_com_google_android_filament_TextureSampler_nGetCompareFunction(JNIEnv *, jclass, jlong sampler) {
-    return static_cast<jint>(from_long(sampler).getCompareFunc());
+Java_com_google_android_filament_TextureSampler_nGetCompareFunction(JNIEnv *env, jclass type,
+        jint sampler_) {
+    TextureSampler &sampler = reinterpret_cast<TextureSampler &>(sampler_);
+    return static_cast<jint>(sampler.getCompareFunc());
 }
 
-extern "C" JNIEXPORT jlong JNICALL
-Java_com_google_android_filament_TextureSampler_nSetCompareFunction(JNIEnv *, jclass, jlong sampler_, jint function) {
-    TextureSampler sampler{from_long(sampler_)};
+extern "C" JNIEXPORT jint JNICALL
+Java_com_google_android_filament_TextureSampler_nSetCompareFunction(JNIEnv *env, jclass type,
+        jint sampler_, jint function) {
+    TextureSampler &sampler = reinterpret_cast<TextureSampler &>(sampler_);
     sampler.setCompareMode(sampler.getCompareMode(),
             static_cast<TextureSampler::CompareFunc>(function));
-    return to_long(sampler);
+    return sampler.getSamplerParams().u;
 }
 
 extern "C" JNIEXPORT jfloat JNICALL
-Java_com_google_android_filament_TextureSampler_nGetAnisotropy(JNIEnv *, jclass, jlong sampler) {
-    return from_long(sampler).getAnisotropy();
+Java_com_google_android_filament_TextureSampler_nGetAnisotropy(JNIEnv *env, jclass type,
+        jint sampler_) {
+    TextureSampler &sampler = reinterpret_cast<TextureSampler &>(sampler_);
+    return sampler.getAnisotropy();
 }
 
-extern "C" JNIEXPORT jlong JNICALL
-Java_com_google_android_filament_TextureSampler_nSetAnisotropy(JNIEnv *, jclass, jlong sampler_, jfloat anisotropy) {
-    TextureSampler sampler{from_long(sampler_)};
+extern "C" JNIEXPORT jint JNICALL
+Java_com_google_android_filament_TextureSampler_nSetAnisotropy(JNIEnv *env, jclass type,
+        jint sampler_, jfloat anisotropy) {
+    TextureSampler &sampler = reinterpret_cast<TextureSampler &>(sampler_);
     sampler.setAnisotropy(anisotropy);
-    return to_long(sampler);
+    return sampler.getSamplerParams().u;
 }

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

@@ -1,108 +0,0 @@
-/*
- * 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_nCreatePBRNeutralToneMapper(JNIEnv*, jclass) {
-    return (jlong) new PBRNeutralToneMapper();
-}
-
-extern "C" JNIEXPORT jlong JNICALL
-Java_com_google_android_filament_ToneMapper_nCreateAgxToneMapper(JNIEnv*, jclass, jint look) {
-    return (jlong) new AgxToneMapper(AgxToneMapper::AgxLook(look));
-}
-
-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,23 +70,6 @@ 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_) {
@@ -110,26 +93,6 @@ Java_com_google_android_filament_TransformManager_nGetParent(JNIEnv*, jclass,
     return tm->getParent((TransformManager::Instance) i).getId();
 }
 
-extern "C" JNIEXPORT jint JNICALL
-Java_com_google_android_filament_TransformManager_nGetChildCount(JNIEnv*, jclass,
-        jlong nativeTransformManager, jint i) {
-    TransformManager* tm = (TransformManager*) nativeTransformManager;
-    return tm->getChildCount((TransformManager::Instance) i);
-}
-
-extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_TransformManager_nGetChildren(JNIEnv* env,
-        jclass, jlong nativeTransformManager, jint i,
-        jintArray outEntities_, jint count) {
-    TransformManager* tm = (TransformManager*) nativeTransformManager;
-    jint* entities = env->GetIntArrayElements(outEntities_, nullptr);
-    // This is very very gross, we just pretend Entity is just like an jint
-    // (which it is), but still.
-    tm->getChildren((TransformManager::Instance) i,
-            reinterpret_cast<Entity *>(entities), (size_t) count);
-    env->ReleaseIntArrayElements(outEntities_, entities, 0);
-}
-
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_TransformManager_nSetTransform(JNIEnv* env,
         jclass, jlong nativeTransformManager, jint i,
@@ -141,17 +104,6 @@ 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,
@@ -163,17 +115,6 @@ 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,
@@ -185,17 +126,6 @@ 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) {
@@ -209,19 +139,3 @@ 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,40 +32,40 @@ using namespace filament::math;
 using namespace backend;
 
 extern "C" JNIEXPORT jlong JNICALL
-Java_com_google_android_filament_VertexBuffer_nCreateBuilder(JNIEnv*, jclass) {
+Java_com_google_android_filament_VertexBuffer_nCreateBuilder(JNIEnv *env, jclass type) {
     return (jlong) new VertexBuffer::Builder();
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_VertexBuffer_nDestroyBuilder(JNIEnv*, jclass,
+Java_com_google_android_filament_VertexBuffer_nDestroyBuilder(JNIEnv *env, jclass type,
         jlong nativeBuilder) {
     VertexBuffer::Builder* builder = (VertexBuffer::Builder *) nativeBuilder;
     delete builder;
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_VertexBuffer_nBuilderVertexCount(JNIEnv*, jclass,
+Java_com_google_android_filament_VertexBuffer_nBuilderVertexCount(JNIEnv *env, jclass type,
         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_nBuilderEnableBufferObjects(JNIEnv*, jclass,
+Java_com_google_android_filament_VertexBuffer_nBuilderEnableBufferObjects(JNIEnv *env, jclass type,
         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,
+Java_com_google_android_filament_VertexBuffer_nBuilderBufferCount(JNIEnv *env, jclass type,
         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*, jclass,
+Java_com_google_android_filament_VertexBuffer_nBuilderAttribute(JNIEnv *env, jclass type,
         jlong nativeBuilder, jint attribute, jint bufferIndex, jint attributeType, jint byteOffset,
         jint byteStride) {
     VertexBuffer::Builder* builder = (VertexBuffer::Builder *) nativeBuilder;
@@ -75,14 +75,14 @@ Java_com_google_android_filament_VertexBuffer_nBuilderAttribute(JNIEnv*, jclass,
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_VertexBuffer_nBuilderNormalized(JNIEnv*, jclass,
+Java_com_google_android_filament_VertexBuffer_nBuilderNormalized(JNIEnv *env, jclass type,
         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*, jclass,
+Java_com_google_android_filament_VertexBuffer_nBuilderBuild(JNIEnv *env, jclass type,
         jlong nativeBuilder, jlong nativeEngine) {
     VertexBuffer::Builder* builder = (VertexBuffer::Builder *) nativeBuilder;
     Engine *engine = (Engine *) nativeEngine;
@@ -90,14 +90,14 @@ Java_com_google_android_filament_VertexBuffer_nBuilderBuild(JNIEnv*, jclass,
 }
 
 extern "C" JNIEXPORT jint JNICALL
-Java_com_google_android_filament_VertexBuffer_nGetVertexCount(JNIEnv*, jclass,
+Java_com_google_android_filament_VertexBuffer_nGetVertexCount(JNIEnv *env, jclass type,
         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,
+Java_com_google_android_filament_VertexBuffer_nSetBufferAt(JNIEnv *env, jclass type,
         jlong nativeVertexBuffer, jlong nativeEngine, jint bufferIndex,
         jobject buffer, jint remaining,
         jint destOffsetInBytes, jint count, jobject handler, jobject runnable) {
@@ -114,8 +114,7 @@ Java_com_google_android_filament_VertexBuffer_nSetBufferAt(JNIEnv *env, jclass,
 
     auto* callback = JniBufferCallback::make(engine, env, handler, runnable, std::move(nioBuffer));
 
-    BufferDescriptor desc(data, sizeInBytes,
-            callback->getHandler(), &JniBufferCallback::postToJavaAndDestroy, callback);
+    BufferDescriptor desc(data, sizeInBytes, &JniBufferCallback::invoke, callback);
 
     vertexBuffer->setBufferAt(*engine, (uint8_t) bufferIndex, std::move(desc),
             (uint32_t) destOffsetInBytes);
@@ -124,10 +123,50 @@ Java_com_google_android_filament_VertexBuffer_nSetBufferAt(JNIEnv *env, jclass,
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_VertexBuffer_nSetBufferObjectAt(JNIEnv*, jclass,
+Java_com_google_android_filament_VertexBuffer_nSetBufferObjectAt(JNIEnv *env, jclass type,
         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);
 }
+
+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
+    });
+}

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

@@ -20,10 +20,6 @@
 #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
@@ -49,12 +45,6 @@ Java_com_google_android_filament_View_nSetCamera(JNIEnv*, jclass,
     view->setCamera(camera);
 }
 
-extern "C" JNIEXPORT jboolean JNICALL
-Java_com_google_android_filament_View_nHasCamera(JNIEnv*, jclass, jlong nativeView) {
-    View* view = (View*) nativeView;
-    return (jboolean)view->hasCamera();
-}
-
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_View_nSetColorGrading(JNIEnv*, jclass,
         jlong nativeView, jlong nativeColorGrading) {
@@ -92,19 +82,13 @@ 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
@@ -135,14 +119,13 @@ 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, jfloat sharpness, jint quality) {
+        jfloat minScale, jfloat maxScale, 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);
 }
@@ -155,28 +138,13 @@ Java_com_google_android_filament_View_nSetShadowType(JNIEnv*, jclass, jlong nati
 
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_View_nSetVsmShadowOptions(JNIEnv*, jclass, jlong nativeView,
-        jint anisotropy, jboolean mipmapping, jboolean highPrecision, jfloat minVarianceScale,
-        jfloat lightBleedReduction) {
+        jint anisotropy) {
     View* view = (View*) nativeView;
     View::VsmShadowOptions options;
-    options.anisotropy = (uint8_t)anisotropy;
-    options.mipmapping = (bool)mipmapping;
-    options.highPrecision = (bool)highPrecision;
-    options.minVarianceScale = minVarianceScale;
-    options.lightBleedReduction = lightBleedReduction;
+    options.anisotropy = (uint8_t) anisotropy;
     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,
@@ -222,20 +190,6 @@ Java_com_google_android_filament_View_nIsFrontFaceWindingInverted(JNIEnv*,
     return static_cast<jboolean>(view->isFrontFaceWindingInverted());
 }
 
-extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_View_nSetTransparentPickingEnabled(JNIEnv*,
-        jclass, jlong nativeView, jboolean enabled) {
-    View* view = (View*) nativeView;
-    view->setTransparentPickingEnabled(enabled);
-}
-
-extern "C" JNIEXPORT jboolean JNICALL
-Java_com_google_android_filament_View_nIsTransparentPickingEnabled(JNIEnv*,
-        jclass, jlong nativeView) {
-    View* view = (View*) nativeView;
-    return static_cast<jboolean>(view->isTransparentPickingEnabled());
-}
-
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_View_nSetAmbientOcclusion(JNIEnv*, jclass, jlong nativeView, jint ordinal) {
     View* view = (View*) nativeView;
@@ -257,9 +211,7 @@ 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,
-    jfloat bilateralThreshold,
-    jint quality, jint lowPassFilter, jint upsampling, jboolean enabled, jboolean bentNormals,
-    jfloat minHorizonAngleRad) {
+    jint quality, jint lowPassFilter, jint upsampling, jboolean enabled, jfloat minHorizonAngleRad) {
     View* view = (View*) nativeView;
     View::AmbientOcclusionOptions options = view->getAmbientOcclusionOptions();
     options.radius = radius;
@@ -267,12 +219,10 @@ Java_com_google_android_filament_View_nSetAmbientOcclusionOptions(JNIEnv*, jclas
     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);
 }
@@ -280,14 +230,14 @@ Java_com_google_android_filament_View_nSetAmbientOcclusionOptions(JNIEnv*, jclas
 
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_View_nSetSSCTOptions(JNIEnv *, jclass, jlong nativeView,
-        jfloat ssctLightConeRad, jfloat ssctShadowDistance, jfloat ssctContactDistanceMax,
+        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 = ssctShadowDistance;
+    options.ssct.shadowDistance = ssctStartTraceDistance;
     options.ssct.contactDistanceMax = ssctContactDistanceMax;
     options.ssct.intensity = ssctIntensity;
     options.ssct.lightDirection = math::float3{ ssctLightDirX, ssctLightDirY, ssctLightDirZ };
@@ -302,11 +252,8 @@ Java_com_google_android_filament_View_nSetSSCTOptions(JNIEnv *, jclass, jlong na
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_View_nSetBloomOptions(JNIEnv*, jclass,
         jlong nativeView, jlong nativeTexture,
-        jfloat dirtStrength, jfloat strength, jint resolution, jint levels,
-        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) {
+        jfloat dirtStrength, jfloat strength, jint resolution, jfloat anamorphism, jint levels,
+        jint blendMode, jboolean threshold, jboolean enabled, jfloat highlight) {
     View* view = (View*) nativeView;
     Texture* dirt = (Texture*) nativeTexture;
     View::BloomOptions options = {
@@ -314,34 +261,24 @@ Java_com_google_android_filament_View_nSetBloomOptions(JNIEnv*, jclass,
             .dirtStrength = dirtStrength,
             .strength = strength,
             .resolution = (uint32_t)resolution,
+            .anamorphism = anamorphism,
             .levels = (uint8_t)levels,
             .blendMode = (View::BloomOptions::BlendMode)blendMode,
             .threshold = (bool)threshold,
             .enabled = (bool)enabled,
-            .highlight = highlight,
-            .lensFlare = (bool)lensFlare,
-            .starburst = (bool)starburst,
-            .chromaticAberration = chromaticAberration,
-            .ghostCount = (uint8_t)ghostCount,
-            .ghostSpacing = ghostSpacing,
-            .ghostThreshold = ghostThreshold,
-            .haloThickness = haloThickness,
-            .haloRadius = haloRadius,
-            .haloThreshold = haloThreshold
+            .highlight = highlight
     };
     view->setBloomOptions(options);
 }
 
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_View_nSetFogOptions(JNIEnv *, jclass , jlong nativeView,
-        jfloat distance, jfloat maximumOpacity, jfloat height, jfloat heightFalloff, jfloat cutOffDistance,
-        jfloat r, jfloat g, jfloat b, jfloat density, jfloat inScatteringStart,
-        jfloat inScatteringSize, jboolean fogColorFromIbl, jlong skyColorNativeObject, jboolean enabled) {
+        jfloat distance, jfloat maximumOpacity, jfloat height, jfloat heightFalloff, jfloat r,
+        jfloat g, jfloat b, jfloat density, jfloat inScatteringStart,
+        jfloat inScatteringSize, jboolean fogColorFromIbl, jboolean enabled) {
     View* view = (View*) nativeView;
-    Texture* skyColor = (Texture*) skyColorNativeObject;
     View::FogOptions options = {
              .distance = distance,
-             .cutOffDistance = cutOffDistance,
              .maximumOpacity = maximumOpacity,
              .height = height,
              .heightFalloff = heightFalloff,
@@ -350,7 +287,6 @@ Java_com_google_android_filament_View_nSetFogOptions(JNIEnv *, jclass , jlong na
              .inScatteringStart = inScatteringStart,
              .inScatteringSize = inScatteringSize,
              .fogColorFromIbl = (bool)fogColorFromIbl,
-             .skyColor = skyColor,
              .enabled = (bool)enabled
     };
     view->setFogOptions(options);
@@ -363,8 +299,8 @@ 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 cocScale, jfloat maxApertureDiameter, jboolean enabled, jint filter,
+Java_com_google_android_filament_View_nSetDepthOfFieldOptions(JNIEnv *, jclass ,
+        jlong nativeView, jfloat focusDistance, jfloat cocScale, jfloat maxApertureDiameter, jboolean enabled, jint filter,
         jboolean nativeResolution, jint foregroundRingCount, jint backgroundRingCount, jint fastGatherRingCount,
         jint maxForegroundCOC, jint maxBackgroundCOC) {
     View* view = (View*) nativeView;
@@ -373,7 +309,7 @@ Java_com_google_android_filament_View_nSetDepthOfFieldOptions(JNIEnv *, jclass,
         // View::DepthOfFieldOptions::Filter::MEDIAN value is actually 2
         eFilter = View::DepthOfFieldOptions::Filter::MEDIAN;
     }
-    view->setDepthOfFieldOptions({.cocScale = cocScale,
+    view->setDepthOfFieldOptions({.focusDistance = focusDistance, .cocScale = cocScale,
             .maxApertureDiameter = maxApertureDiameter, .enabled = (bool)enabled, .filter = eFilter,
             .nativeResolution = (bool)nativeResolution,
             .foregroundRingCount = (uint8_t)foregroundRingCount,
@@ -393,17 +329,6 @@ 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,
@@ -413,16 +338,6 @@ Java_com_google_android_filament_View_nSetTemporalAntiAliasingOptions(JNIEnv *,
             .filterWidth = filterWidth, .feedback = feedback, .enabled = (bool) enabled});
 }
 
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_google_android_filament_View_nSetScreenSpaceReflectionsOptions(JNIEnv*, jclass,
-        jlong nativeView, jfloat thickness, jfloat bias, jfloat maxDistance, jfloat stride, jboolean enabled) {
-    View* view = (View*) nativeView;
-    view->setScreenSpaceReflectionsOptions({.thickness = thickness, .bias = bias,
-            .maxDistance = maxDistance, .stride = stride, .enabled = (bool) enabled
-    });
-}
-
 extern "C"
 JNIEXPORT jboolean JNICALL
 Java_com_google_android_filament_View_nIsShadowingEnabled(JNIEnv *, jclass, jlong nativeView) {
@@ -445,112 +360,3 @@ Java_com_google_android_filament_View_nIsScreenSpaceRefractionEnabled(JNIEnv *,
     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());
-}
-
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_google_android_filament_View_nSetStencilBufferEnabled(JNIEnv *, jclass, jlong nativeView,
-        jboolean enabled) {
-    View* view = (View*) nativeView;
-    view->setStencilBufferEnabled(enabled);
-}
-
-extern "C"
-JNIEXPORT jboolean JNICALL
-Java_com_google_android_filament_View_nIsStencilBufferEnabled(JNIEnv *, jclass, jlong nativeView) {
-    View* view = (View*) nativeView;
-    return view->isStencilBufferEnabled();
-}
-
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_google_android_filament_View_nSetStereoscopicOptions(JNIEnv *, jclass, jlong nativeView,
-        jboolean enabled) {
-    View* view = (View*) nativeView;
-    View::StereoscopicOptions options {
-        .enabled = (bool) enabled
-    };
-    view->setStereoscopicOptions(options);
-}
-
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_google_android_filament_View_nSetGuardBandOptions(JNIEnv *, jclass,
-        jlong nativeView, jboolean enabled) {
-    View* view = (View*) nativeView;
-    view->setGuardBandOptions({ .enabled = (bool)enabled });
-}
-
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_google_android_filament_View_nSetMaterialGlobal(JNIEnv * , jclass, jlong nativeView,
-        jint index, jfloat x, jfloat y, jfloat z, jfloat w) {
-    View *view = (View *) nativeView;
-    view->setMaterialGlobal((uint32_t)index, { x, y, z, w });
-}
-
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_google_android_filament_View_nGetMaterialGlobal(JNIEnv *env, jclass clazz,
-        jlong nativeView, jint index, jfloatArray out_) {
-    jfloat* out = env->GetFloatArrayElements(out_, nullptr);
-    View *view = (View *) nativeView;
-    auto result = view->getMaterialGlobal(index);
-    std::copy_n(result.v, 4, out);
-    env->ReleaseFloatArrayElements(out_, out, 0);
-}
-
-extern "C"
-JNIEXPORT int JNICALL
-Java_com_google_android_filament_View_nGetFogEntity(JNIEnv *env, jclass clazz,
-        jlong nativeView) {
-    View *view = (View *) nativeView;
-    return (jint)view->getFogEntity().getId();
-}
-
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_google_android_filament_View_nClearFrameHistory(JNIEnv *env, jclass clazz,
-        jlong nativeView, jlong nativeEngine) {
-    View *view = (View *) nativeView;
-    Engine *engine = (Engine *) nativeEngine;
-    view->clearFrameHistory(*engine);
-}

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

@@ -0,0 +1,71 @@
+/*
+ * 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

@@ -0,0 +1,116 @@
+/*
+ * 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;
+#if defined(__APPLE__) && defined(__aarch64__)
+        // FIXME: enable Apple Silicon build. The problem here is that we attempt to link an x86 jdk and that fails
+        //        so JAWT_GetAWT doesn't exist at link time.
+#warning "FIXME: JAWT_GetAWT() not supported"
+        foundJawt = {};
+#else
+        foundJawt = JAWT_GetAWT(env, &awt);
+#endif
+        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/JAWTUtils.h

@@ -0,0 +1,23 @@
+/*
+ * 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 <jawt.h>
+
+extern "C" {
+bool acquireDrawingSurface(JNIEnv* env, jobject surface, JAWT_DrawingSurface** ods,
+        JAWT_DrawingSurfaceInfo** odsi);
+void releaseDrawingSurface(JAWT_DrawingSurface* ds, JAWT_DrawingSurfaceInfo* dsi);
+}

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

@@ -0,0 +1,90 @@
+/*
+ * 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

@@ -0,0 +1,67 @@
+/*
+ * 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,27 +63,12 @@ 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

@@ -72,7 +72,7 @@ public class BufferObject {
         /**
          * The binding type for this buffer object. (defaults to VERTEX)
          *
-         * @param bindingType Distinguishes between SSBO, VBO, etc. For now this must be VERTEX.
+         * @param BindingType Distinguishes between SSBO, VBO, etc. For now this must be VERTEX.
          * @return A reference to this Builder for chaining calls.
          */
         @NonNull

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

@@ -29,7 +29,7 @@ import androidx.annotation.Size;
  *
  * 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)} ()}.
+ * {@link Engine#destroyCamera(Camera)}.
  *
  * <pre>
  *  Camera myCamera = engine.createCamera(myCameraEntity);
@@ -37,7 +37,7 @@ import androidx.annotation.Size;
  *  myCamera.lookAt(0, 1.60, 1,
  *                  0, 0, 0,
  *                  0, 1, 0);
- *  engine.destroyCameraComponent(myCameraEntity);
+ *  engine.destroyCamera(myCamera);
  * </pre>
  *
  *
@@ -121,9 +121,6 @@ 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
@@ -146,9 +143,8 @@ public class Camera {
         HORIZONTAL
     }
 
-    Camera(long nativeCamera, @Entity int entity) {
+    Camera(long nativeCamera) {
         mNativeObject = nativeCamera;
-        mEntity = entity;
     }
 
     /**
@@ -254,9 +250,6 @@ public class Camera {
     /**
      * Sets a 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.
@@ -282,9 +275,6 @@ public class Camera {
     /**
      * 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.
@@ -365,7 +355,7 @@ public class Camera {
      * By default, this is an identity matrix.
      * </p>
      *
-     * @param inScaling     diagonal of the scaling matrix to be applied after the projection matrix.
+     * @param scaling     diagonal of the scaling matrix to be applied after the projection matrix.
      *
      * @see Camera#setProjection
      * @see Camera#setLensProjection
@@ -400,7 +390,7 @@ public class Camera {
     }
 
     /**
-     * Sets the camera's model matrix.
+     * 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.
@@ -409,32 +399,18 @@ public class Camera {
      *
      * <pre>
      *  engine.getTransformManager().setTransform(
-     *          engine.getTransformManager().getInstance(camera->getEntity()), modelMatrix);
+     *          engine.getTransformManager().getInstance(camera->getEntity()), viewMatrix);
      * </pre>
      *
-     * @param modelMatrix The camera position and orientation provided as a <b>rigid transform</b> matrix.
+     * @param viewMatrix The camera position and orientation provided as a <b>rigid transform</b> matrix.
      */
-    public void setModelMatrix(@NonNull @Size(min = 16) float[] modelMatrix) {
-        Asserts.assertMat4fIn(modelMatrix);
-        nSetModelMatrix(getNativeObject(), modelMatrix);
+    public void setModelMatrix(@NonNull @Size(min = 16) float[] viewMatrix) {
+        Asserts.assertMat4fIn(viewMatrix);
+        nSetModelMatrix(getNativeObject(), viewMatrix);
     }
 
     /**
-     * Sets the camera's model matrix.
-     * <p>
-     * Helper method to set the camera's entity transform component.
-     * Remember that the Camera "looks" towards its -z axis.
-     * <p>
-     *
-     * @param modelMatrix The camera position and orientation provided as a <b>rigid transform</b> matrix.
-     */
-    public void setModelMatrix(@NonNull @Size(min = 16) double[] modelMatrix) {
-        Asserts.assertMat4In(modelMatrix);
-        nSetModelMatrixFp64(getNativeObject(), modelMatrix);
-    }
-
-    /**
-     * Sets the camera's model matrix.
+     * Sets the camera's view matrix.
      *
      * @param eyeX      x-axis position of the camera in world space
      * @param eyeY      y-axis position of the camera in world space
@@ -456,7 +432,7 @@ public class Camera {
      * @return Distance to the near plane
      */
     public float getNear() {
-        return (float)nGetNear(getNativeObject());
+        return nGetNear(getNativeObject());
     }
 
     /**
@@ -464,7 +440,7 @@ public class Camera {
      * @return Distance to the far plane
      */
     public float getCullingFar() {
-        return (float)nGetCullingFar(getNativeObject());
+        return nGetCullingFar(getNativeObject());
     }
 
     /**
@@ -530,29 +506,13 @@ 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.
      *
-     * @param out A 16-float array where the view matrix will be stored, or null in which
+     * @param out A 16-float array where the model view will be stored, or null in which
      *            case a new array is allocated.
      *
-     * @return A 16-float array containing the camera's column-major view matrix.
+     * @return A 16-float array containing the camera's view as a column-major matrix.
      */
     @NonNull @Size(min = 16)
     public float[] getViewMatrix(@Nullable @Size(min = 16) float[] out) {
@@ -561,21 +521,6 @@ 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 column-major view 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.
      *
@@ -736,15 +681,6 @@ public class Camera {
         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
      *
@@ -785,17 +721,14 @@ public class Camera {
     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 double nGetNear(long nativeCamera);
-    private static native double nGetCullingFar(long nativeCamera);
+    private static native float nGetNear(long nativeCamera);
+    private static native float nGetCullingFar(long nativeCamera);
     private static native void nGetProjectionMatrix(long nativeCamera, double[] out);
     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);

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

@@ -54,8 +54,6 @@ 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>
@@ -65,16 +63,12 @@ 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>,
@@ -84,13 +78,11 @@ 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 ToneMapper.ACESLegacy}</li>
- * <li>Luminance scaling: false</li>
- * <li>Gamut mapping: false</li>
+ * <li>Tone mapping: {@link ToneMapping#ACES_LEGACY}</li>
  * </ul>
  *
  * @see View
- * @see ToneMapper
+ * @see ToneMapping
  */
 public class ColorGrading {
     long mNativeObject;
@@ -105,20 +97,9 @@ public class ColorGrading {
         ULTRA
     }
 
-    /**
-     * Color grading LUT format.
-     */
-    public enum LutFormat {
-        INTEGER,
-        FLOAT
-    }
-
     /**
      * List of available tone-mapping operators.
-     *
-     * @deprecated Use {@link ColorGrading.Builder#toneMapper(ToneMapper)}
      */
-    @Deprecated
     public enum ToneMapping {
         /** Linear tone mapping (i.e. no tone mapping). */
         LINEAR,
@@ -128,6 +109,10 @@ 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,
     }
@@ -171,55 +156,6 @@ public class ColorGrading {
             return this;
         }
 
-        /**
-         * When color grading is implemented using a 3D LUT, this sets the texture format of
-         * of the LUT. This overrides the value set by quality().
-         *
-         * The default is INTEGER
-         *
-         * @param format The desired format of the 3D LUT.
-         *
-         * @return This Builder, for chaining calls
-         */
-        public Builder format(LutFormat format) {
-            nBuilderFormat(mNativeBuilder, format.ordinal());
-            return this;
-        }
-
-        /**
-         * When color grading is implemented using a 3D LUT, this sets the dimension of the LUT.
-         * This overrides the value set by quality().
-         *
-         * The default is 32
-         *
-         * @param dim The desired dimension of the LUT. Between 16 and 64.
-         *
-         * @return This Builder, for chaining calls
-         */
-        public Builder dimensions(int dim) {
-            nBuilderDimensions(mNativeBuilder, dim);
-            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.
@@ -229,82 +165,12 @@ 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)}
          */
-        @Deprecated
         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
@@ -597,14 +463,7 @@ public class ColorGrading {
     private static native void nDestroyBuilder(long nativeBuilder);
 
     private static native void nBuilderQuality(long nativeBuilder, int quality);
-    private static native void nBuilderFormat(long nativeBuilder, int format);
-    private static native void nBuilderDimensions(long nativeBuilder, int dim);
-    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 nBuilderToneMapping(long nativeBuilder, int toneMapper);
     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/EntityManager.java

@@ -31,10 +31,6 @@ 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

@@ -84,7 +84,11 @@ import androidx.annotation.Size;
 public class IndirectLight {
     long mNativeObject;
 
-    public IndirectLight(long indirectLight) {
+    public IndirectLight(Engine engine, long indirectLight) {
+        mNativeObject = indirectLight;
+    }
+
+    IndirectLight(long indirectLight) {
         mNativeObject = indirectLight;
     }
 

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

@@ -117,8 +117,6 @@ import androidx.annotation.Size;
  * </ul>
  */
 public class LightManager {
-    private static final Type[] sTypeValues = Type.values();
-
     private long mNativeObject;
 
     LightManager(long nativeLightManager) {
@@ -190,7 +188,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 and larger or equal to 8. */
+        /** Size of the shadow map in texels. Must be a power-of-two. */
         public int mapSize = 1024;
 
         /**
@@ -240,25 +238,22 @@ public class LightManager {
          */
         @NonNull
         @Size(min = 3)
-        public float[] cascadeSplitPositions = { 0.125f, 0.25f, 0.50f };
+        public float[] cascadeSplitPositions = { 0.25f, 0.50f, 0.75f };
 
         /** 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.001f;
+        public float constantBias = 0.05f;
 
         /** 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 = 1.0f;
+        public float normalBias = 0.4f;
 
-        /** 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.
-         * This only affect directional lights.
          */
         public float shadowFar = 0.0f;
 
@@ -281,41 +276,8 @@ public class LightManager {
          * Controls whether the shadow map should be optimized for resolution or stability.
          * When set to true, all resolution enhancing features that can affect stability are
          * disabling, resulting in significantly lower resolution shadows, albeit stable ones.
-         *
-         * Setting this flag to true always disables LiSPSM (see below).
          */
-        public boolean stable = false;
-
-        /**
-         * LiSPSM, or light-space perspective shadow-mapping is a technique allowing to better
-         * optimize the use of the shadow-map texture. When enabled the effective resolution of
-         * shadows is greatly improved and yields result similar to using cascades without the
-         * extra cost. LiSPSM comes with some drawbacks however, in particular it is incompatible
-         * with blurring because it effectively affects the blur kernel size.
-         *
-         * Blurring is only an issue when using ShadowType.VSM with a large blur or with
-         * ShadowType.PCSS however.
-         *
-         * If these blurring artifacts become problematic, this flag can be used to disable LiSPSM.
-         */
-        public boolean lispsm = 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;
+        public boolean stable = true;
 
         /**
          * Whether screen-space contact shadows are used. This applies regardless of whether a
@@ -351,35 +313,17 @@ public class LightManager {
          */
 
         /**
-         * When elvsm is set to true, "Exponential Layered VSM without Layers" are used. It is
-         * an improvement to the default EVSM which suffers important light leaks. Enabling
-         * ELVSM for a single shadowmap doubles the memory usage of all shadow maps.
-         * ELVSM is mostly useful when large blurs are used.
+         * 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>
          */
-        public boolean elvsm = false;
-
-        /**
-         * 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;
-
-        /**
-         * Transforms the shadow direction. Must be a unit quaternion.
-         * The default is identity.
-         * Ignored if the light type isn't directional. For artistic use. Use with caution.
-         * The quaternion is stored as the imaginary part in the first 3 elements and the real
-         * part in the last element of the transform array.
-         */
-        @NonNull
-        @Size(min = 4, max = 4)
-        public float[] transform = { 0.0f, 0.0f, 0.0f, 1.0f };
+        @IntRange(from = 1)
+        public int vsmMsaaSamples = 1;
     }
 
     public static class ShadowCascades {
@@ -478,21 +422,14 @@ 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)
          *
+         * <p>
+         * <b>warning:</b>
+         *  {@link Type#POINT} lights cannot cast shadows.
+         * </p>
+         *
          * @param enable Enables or disables casting shadows from this Light.
          *
          * @return This Builder, for chaining calls.
@@ -514,11 +451,8 @@ public class LightManager {
             nBuilderShadowOptions(mNativeBuilder,
                     options.mapSize, options.shadowCascades, options.cascadeSplitPositions,
                     options.constantBias, options.normalBias, options.shadowFar, options.shadowNearHint,
-                    options.shadowFarHint, options.stable, options.lispsm,
-                    options.polygonOffsetConstant, options.polygonOffsetSlope,
-                    options.screenSpaceContactShadows,
-                    options.stepCount, options.maxShadowDistance,
-                    options.elvsm, options.blurWidth, options.shadowBulbRadius, options.transform);
+                    options.shadowFarHint, options.stable, options.screenSpaceContactShadows,
+                    options.stepCount, options.maxShadowDistance, options.vsmMsaaSamples);
             return this;
         }
 
@@ -807,7 +741,7 @@ public class LightManager {
 
     @NonNull
     public Type getType(@EntityInstance int i) {
-        return sTypeValues[nGetType(mNativeObject, i)];
+        return Type.values()[nGetType(mNativeObject, i)];
     }
 
     /**
@@ -842,30 +776,6 @@ 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.
      *
@@ -1016,6 +926,8 @@ public class LightManager {
      *                      lightbulbs.
      *
      * @param efficiency    Efficiency in percent. This depends on the type of lightbulb used.
+     *
+     * @return This Builder, for chaining calls.
      */
     public void setIntensity(@EntityInstance int i, float watts, float efficiency) {
         nSetIntensity(mNativeObject, i , watts, efficiency);
@@ -1153,14 +1065,6 @@ 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;
     }
@@ -1174,14 +1078,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 lispsm,
-             float polygonOffsetConstant, float polygonOffsetSlope,
-             boolean screenSpaceContactShadows, int stepCount, float maxShadowDistance,
-             boolean elvsm, float blurWidth, float shadowBulbRadius, float[] transform);
+    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, int vsmMsaaSamples);
     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);
@@ -1194,7 +1091,6 @@ 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);
@@ -1222,8 +1118,4 @@ 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

@@ -18,11 +18,9 @@ package com.google.android.filament;
 
 import androidx.annotation.IntRange;
 import androidx.annotation.NonNull;
-import androidx.annotation.Nullable;
 import androidx.annotation.Size;
 
 import com.google.android.filament.proguard.UsedByNative;
-import com.google.android.filament.Engine.FeatureLevel;
 
 import java.nio.Buffer;
 import java.util.ArrayList;
@@ -38,24 +36,7 @@ import java.util.Set;
  *
  * @see <a href="https://google.github.io/filament/Materials.html">Filament Materials Guide</a>
  */
-@UsedByNative("AssetLoader.cpp")
 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 ReflectionMode[] sReflectionModeValues = ReflectionMode.values();
-        static final FeatureLevel[] sFeatureLevelValues = FeatureLevel.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;
 
@@ -185,18 +166,6 @@ public class Material {
         THIN
     }
 
-    /**
-     * Supported reflection modes
-     *
-     * @see
-     * <a href="https://google.github.io/filament/Materials.html#materialdefinitions/materialblock/lighting:reflections">
-     * Lighting: reflections</a>
-     */
-    public enum ReflectionMode {
-        DEFAULT,
-        SCREEN_SPACE
-    }
-
     /**
      * Supported types of vertex domains
      *
@@ -239,35 +208,8 @@ public class Material {
         FRONT_AND_BACK
     }
 
-    public enum CompilerPriorityQueue {
-        HIGH,
-        LOW
-    }
-
-    public static class UserVariantFilterBit {
-        /** Directional lighting */
-        public static int DIRECTIONAL_LIGHTING = 0x01;
-        /** Dynamic lighting */
-        public static int DYNAMIC_LIGHTING = 0x02;
-        /** Shadow receiver */
-        public static int SHADOW_RECEIVER = 0x04;
-        /** Skinning */
-        public static int SKINNING = 0x08;
-        /** Fog */
-        public static int FOG = 0x10;
-        /** Variance shadow maps */
-        public static int VSM = 0x20;
-        /** Screen-space reflections */
-        public static int SSR = 0x40;
-        /** Instanced stereo rendering */
-        public static int STE = 0x80;
-        public static int ALL = 0xFF;
-    }
-
     @UsedByNative("Material.cpp")
     public static class Parameter {
-        private static final Type[] sTypeValues = Type.values();
-
         public enum Type {
             BOOL,
             BOOL2,
@@ -333,11 +275,11 @@ public class Material {
                 @IntRange(from = 0) int type, @IntRange(from = 0) int precision,
                 @IntRange(from = 1) int count) {
             parameters.add(
-                    new Parameter(name, sTypeValues[type], Precision.values()[precision], count));
+                    new Parameter(name, Type.values()[type], Precision.values()[precision], count));
         }
     }
 
-    public Material(long nativeMaterial) {
+    Material(long nativeMaterial) {
         mNativeObject = nativeMaterial;
         long nativeDefaultInstance = nGetDefaultInstance(nativeMaterial);
         mDefaultInstance = new MaterialInstance(this, nativeDefaultInstance);
@@ -346,7 +288,6 @@ public class Material {
     public static class Builder {
         private Buffer mBuffer;
         private int mSize;
-        private int mShBandCount = 0;
 
         /**
          * Specifies the material data. The material data is a binary blob produced by
@@ -362,22 +303,6 @@ public class Material {
             return this;
         }
 
-        /**
-         * Sets the quality of the indirect lights computations. This is only taken into account
-         * if this material is lit and in the surface domain. This setting will affect the
-         * IndirectLight computation if one is specified on the Scene and Spherical Harmonics
-         * are used for the irradiance.
-         *
-         * @param shBandCount Number of spherical harmonic bands. Must be 1, 2 or 3 (default).
-         * @return Reference to this Builder for chaining calls.
-         * @see IndirectLight
-         */
-        @NonNull
-        public Builder sphericalHarmonicsBandCount(@IntRange(from = 0) int shBandCount) {
-            mShBandCount = shBandCount;
-            return this;
-        }
-
         /**
          * Creates and returns the Material object.
          *
@@ -389,62 +314,12 @@ public class Material {
          */
         @NonNull
         public Material build(@NonNull Engine engine) {
-            long nativeMaterial = nBuilderBuild(engine.getNativeObject(),
-                mBuffer, mSize, mShBandCount);
+            long nativeMaterial = nBuilderBuild(engine.getNativeObject(), mBuffer, mSize);
             if (nativeMaterial == 0) throw new IllegalStateException("Couldn't create Material");
             return new Material(nativeMaterial);
         }
     }
 
-
-    /**
-     * Asynchronously ensures that a subset of this Material's variants are compiled. After issuing
-     * several compile() calls in a row, it is recommended to call {@link Engine#flush}
-     * such that the backend can start the compilation work as soon as possible.
-     * The provided callback is guaranteed to be called on the main thread after all specified
-     * variants of the material are compiled. This can take hundreds of milliseconds.
-     *<p>
-     * If all the material's variants are already compiled, the callback will be scheduled as
-     * soon as possible, but this might take a few dozen millisecond, corresponding to how
-     * many previous frames are enqueued in the backend. This also varies by backend. Therefore,
-     * it is recommended to only call this method once per material shortly after creation.
-     *</p>
-     *<p>
-     * If the same variant is scheduled for compilation multiple times, the first scheduling
-     * takes precedence; later scheduling are ignored.
-     *</p>
-     *<p>
-     * caveat: A consequence is that if a variant is scheduled on the low priority queue and later
-     * scheduled again on the high priority queue, the later scheduling is ignored.
-     * Therefore, the second callback could be called before the variant is compiled.
-     * However, the first callback, if specified, will trigger as expected.
-     *</p>
-     *<p>
-     * The callback is guaranteed to be called. If the engine is destroyed while some material
-     * variants are still compiling or in the queue, these will be discarded and the corresponding
-     * callback will be called. In that case however the Material pointer passed to the callback
-     * is guaranteed to be invalid (either because it's been destroyed by the user already, or,
-     * because it's been cleaned-up by the Engine).
-     *</p>
-     *<p>
-     * {@link UserVariantFilterBit#ALL} should be used with caution. Only variants that an application
-     * needs should be included in the variants argument. For example, the STE variant is only used
-     * for stereoscopic rendering. If an application is not planning to render in stereo, this bit
-     * should be turned off to avoid unnecessary material compilations.
-     *</p>
-     * @param priority      Which priority queue to use, LOW or HIGH.
-     * @param variants      Variants to include to the compile command.
-     * @param handler       An {@link java.util.concurrent.Executor Executor}. On Android this can also be a {@link android.os.Handler Handler}.
-     * @param callback      callback called on the main thread when the compilation is done on
-     *                      by backend.
-     */
-    public void compile(@NonNull CompilerPriorityQueue priority,
-                        int variants,
-                        @Nullable Object handler,
-                        @Nullable Runnable callback) {
-        nCompile(getNativeObject(), priority.ordinal(), variants, handler, callback);
-    }
-
     /**
      * Creates a new instance of this material. Material instances should be freed using
      * {@link Engine#destroyMaterialInstance(MaterialInstance)}.
@@ -498,7 +373,7 @@ public class Material {
      * Material Models</a>
      */
     public Shading getShading() {
-        return EnumCache.sShadingValues[nGetShading(getNativeObject())];
+        return Shading.values()[nGetShading(getNativeObject())];
     }
 
     /**
@@ -509,7 +384,7 @@ public class Material {
      * Vertex and attributes: interpolation</a>
      */
     public Interpolation getInterpolation() {
-        return EnumCache.sInterpolationValues[nGetInterpolation(getNativeObject())];
+        return Interpolation.values()[nGetInterpolation(getNativeObject())];
     }
 
     /**
@@ -520,7 +395,7 @@ public class Material {
      * Blending and transparency: blending</a>
      */
     public BlendingMode getBlendingMode() {
-        return EnumCache.sBlendingModeValues[nGetBlendingMode(getNativeObject())];
+        return BlendingMode.values()[nGetBlendingMode(getNativeObject())];
     }
 
     /**
@@ -531,7 +406,7 @@ public class Material {
      * Blending and transparency: refraction</a>
      */
     public RefractionMode getRefractionMode() {
-        return EnumCache.sRefractionModeValues[nGetRefractionMode(getNativeObject())];
+        return RefractionMode.values()[nGetRefractionMode(getNativeObject())];
     }
 
     /**
@@ -542,30 +417,9 @@ public class Material {
      * Blending and transparency: refractionType</a>
      */
     public RefractionType getRefractionType() {
-        return EnumCache.sRefractionTypeValues[nGetRefractionType(getNativeObject())];
+        return RefractionType.values()[nGetRefractionType(getNativeObject())];
     }
 
-    /**
-     * Returns the reflection mode of this material.
-     *
-     * @see
-     * <a href="https://google.github.io/filament/Materials.html#materialdefinitions/materialblock/lighting:reflections">
-     * Lighting: reflections</a>
-     */
-    public ReflectionMode getReflectionMode() {
-        return EnumCache.sReflectionModeValues[nGetReflectionMode(getNativeObject())];
-    }
-
-    /**
-     * Returns the minimum required feature level for this material.
-     *
-     * @see
-     * <a href="https://google.github.io/filament/Materials.html#materialdefinitions/materialblock/general:featurelevel">
-     * General: featureLevel</a>
-     */
-    public FeatureLevel getFeatureLevel() {
-        return EnumCache.sFeatureLevelValues[nGetFeatureLevel(getNativeObject())];
-    }
 
     /**
      * Returns the vertex domain of this material.
@@ -575,7 +429,7 @@ public class Material {
      * Vertex and attributes: vertexDomain</a>
      */
     public VertexDomain getVertexDomain() {
-        return EnumCache.sVertexDomainValues[nGetVertexDomain(getNativeObject())];
+        return VertexDomain.values()[nGetVertexDomain(getNativeObject())];
     }
 
     /**
@@ -586,7 +440,7 @@ public class Material {
      * Rasterization: culling</a>
      */
     public CullingMode getCullingMode() {
-        return EnumCache.sCullingModeValues[nGetCullingMode(getNativeObject())];
+        return CullingMode.values()[nGetCullingMode(getNativeObject())];
     }
 
     /**
@@ -633,17 +487,6 @@ public class Material {
         return nIsDoubleSided(getNativeObject());
     }
 
-    /**
-     * Indicates whether instances of this material will use alpha to coverage.
-     *
-     * @see
-     * <a href="https://google.github.io/filament/Materials.html#materialdefinitions/materialblock/rasterization:alphatocoverage">
-     * Rasterization: alphaToCoverage</a>
-     */
-    public boolean isAlphaToCoverageEnabled() {
-        return nIsAlphaToCoverageEnabled(getNativeObject());
-    }
-
     /**
      * Returns the alpha mask threshold used when the blending mode is set to masked.
      *
@@ -688,7 +531,7 @@ public class Material {
         if (mRequiredAttributes == null) {
             int bitSet = nGetRequiredAttributes(getNativeObject());
             mRequiredAttributes = EnumSet.noneOf(VertexBuffer.VertexAttribute.class);
-            VertexBuffer.VertexAttribute[] values = EnumCache.sVertexAttributeValues;
+            VertexBuffer.VertexAttribute[] values = VertexBuffer.VertexAttribute.values();
             for (int i = 0; i < values.length; i++) {
                 if ((bitSet & (1 << i)) != 0) {
                     mRequiredAttributes.add(values[i]);
@@ -1041,12 +884,11 @@ public class Material {
         mNativeObject = 0;
     }
 
-    private static native long nBuilderBuild(long nativeEngine, @NonNull Buffer buffer, int size, int shBandCount);
+    private static native long nBuilderBuild(long nativeEngine, @NonNull Buffer buffer, int size);
     private static native long nCreateInstance(long nativeMaterial);
     private static native long nCreateInstanceWithName(long nativeMaterial, @NonNull String name);
     private static native long nGetDefaultInstance(long nativeMaterial);
 
-    private static native void nCompile(long nativeMaterial, int priority, int variants, Object handler, Runnable runnable);
     private static native String nGetName(long nativeMaterial);
     private static native int nGetShading(long nativeMaterial);
     private static native int nGetInterpolation(long nativeMaterial);
@@ -1057,14 +899,11 @@ public class Material {
     private static native boolean nIsDepthWriteEnabled(long nativeMaterial);
     private static native boolean nIsDepthCullingEnabled(long nativeMaterial);
     private static native boolean nIsDoubleSided(long nativeMaterial);
-    private static native boolean nIsAlphaToCoverageEnabled(long nativeMaterial);
     private static native float nGetMaskThreshold(long nativeMaterial);
     private static native float nGetSpecularAntiAliasingVariance(long nativeMaterial);
     private static native float nGetSpecularAntiAliasingThreshold(long nativeMaterial);
     private static native int nGetRefractionMode(long nativeMaterial);
     private static native int nGetRefractionType(long nativeMaterial);
-    private static native int nGetReflectionMode(long nativeMaterial);
-    private static native int nGetFeatureLevel(long nativeMaterial);
 
 
     private static native int nGetParameterCount(long nativeMaterial);

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

@@ -20,11 +20,7 @@ import androidx.annotation.IntRange;
 import androidx.annotation.NonNull;
 import androidx.annotation.Size;
 
-import com.google.android.filament.proguard.UsedByNative;
-
-@UsedByNative("AssetLoader.cpp")
 public class MaterialInstance {
-    private static final Material.CullingMode[] sCullingModeValues = Material.CullingMode.values();
     private Material mMaterial;
     private String mName;
     private long mNativeObject;
@@ -53,54 +49,6 @@ public class MaterialInstance {
         MAT4
     }
 
-    /**
-     * Operations that control how the stencil buffer is updated.
-     */
-    public enum StencilOperation {
-        /**
-         * Keeps the current value.
-         */
-        KEEP,
-        /**
-         * Sets the value to 0.
-         */
-        ZERO,
-        /**
-         * Sets the value to the stencil reference value.
-         */
-        REPLACE,
-        /**
-         * Increments the current value. Clamps to the maximum representable unsigned value.
-         */
-        INCR_CLAMP,
-        /**
-         * Increments the current value. Wraps value to zero when incrementing the maximum
-         * representable unsigned value.
-         */
-        INCR_WRAP,
-        /**
-         * Decrements the current value. Clamps to 0.
-         */
-        DECR_CLAMP,
-        /**
-         * Decrements the current value. Wraps value to the maximum representable unsigned value
-         * when decrementing a value of zero.
-         */
-        DECR_WRAP,
-        /**
-         * Bitwise inverts the current value.
-         */
-        INVERT,
-    }
-
-    public enum StencilFace {
-        FRONT,
-        BACK,
-        FRONT_AND_BACK
-    }
-    // Converts the StencilFace enum ordinal to Filament's equivalent bit field.
-    static final int[] sStencilFaceMapping = {0x1, 0x2, 0x3};
-
     public MaterialInstance(Engine engine, long nativeMaterialInstance) {
         mNativeObject = nativeMaterialInstance;
         mNativeMaterial = nGetMaterial(mNativeObject);
@@ -108,7 +56,6 @@ public class MaterialInstance {
 
     MaterialInstance(@NonNull Material material, long nativeMaterialInstance) {
         mMaterial = material;
-        mNativeMaterial = material.getNativeObject();
         mNativeObject = nativeMaterialInstance;
     }
 
@@ -117,22 +64,6 @@ 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() {
@@ -291,10 +222,6 @@ public class MaterialInstance {
 
     /**
      * Sets a texture and sampler parameter on this material's default instance.
-     * <p>
-     * Note: Depth textures can't be sampled with a linear filter unless the comparison mode is set
-     *       to COMPARE_TO_TEXTURE.
-     * </p>
      *
      * @param name The name of the material texture parameter
      * @param texture The texture to set as parameter
@@ -403,40 +330,19 @@ public class MaterialInstance {
     }
 
     /**
-     * Set-up a custom scissor rectangle; by default it is disabled.
+     * Set up a custom scissor rectangle; by default this encompasses the View.
      *
-     * <p>
-     * The scissor rectangle gets clipped by the View's viewport, in other words, the scissor
-     * cannot affect fragments outside of the View's Viewport.
-     * </p>
-     *
-     * <p>
-     * Currently the scissor is not compatible with dynamic resolution and should always be
-     * disabled when dynamic resolution is used.
-     * </p>
-     *
-     * @param left      left coordinate of the scissor box relative to the viewport
-     * @param bottom    bottom coordinate of the scissor box relative to the viewport
+     * @param left      left coordinate of the scissor box
+     * @param bottom    bottom coordinate of the scissor box
      * @param width     width of the scissor box
      * @param height    height of the scissor box
-     *
-     * @see #unsetScissor
-     * @see View#setViewport
-     * @see View#setDynamicResolutionOptions
      */
     public void setScissor(@IntRange(from = 0) int left, @IntRange(from = 0) int bottom,
             @IntRange(from = 0) int width, @IntRange(from = 0) int height) {
         nSetScissor(getNativeObject(), left, bottom, width, height);
     }
 
-    /**
-     * Returns the scissor rectangle to its default disabled setting.
-     * <p>
-     * Currently the scissor is not compatible with dynamic resolution and should always be
-     * disabled when dynamic resolution is used.
-     * </p>
-     * @see View#setDynamicResolutionOptions
-     */
+    /** Returns the scissor rectangle to its default setting, which encompasses the View. */
     public void unsetScissor() {
         nUnsetScissor(getNativeObject());
     }
@@ -474,14 +380,6 @@ public class MaterialInstance {
         nSetMaskThreshold(getNativeObject(), threshold);
     }
 
-    /**
-     * Gets the minimum alpha value a fragment must have to not be discarded when the blend
-     * mode is MASKED
-     */
-    public float getMaskThreshold() {
-        return nGetMaskThreshold(getNativeObject());
-    }
-
     /**
      * Sets the screen space variance of the filter kernel used when applying specular
      * anti-aliasing. The default value is set to 0.15. The specified value should be between
@@ -495,14 +393,6 @@ public class MaterialInstance {
         nSetSpecularAntiAliasingVariance(getNativeObject(), variance);
     }
 
-    /**
-     * Gets the screen space variance of the filter kernel used when applying specular
-     * anti-aliasing.
-     */
-    public float getSpecularAntiAliasingVariance() {
-        return nGetSpecularAntiAliasingVariance(getNativeObject());
-    }
-
     /**
      * Sets the clamping threshold used to suppress estimation errors when applying specular
      * anti-aliasing. The default value is set to 0.2. The specified value should be between 0
@@ -516,14 +406,6 @@ public class MaterialInstance {
         nSetSpecularAntiAliasingThreshold(getNativeObject(), threshold);
     }
 
-    /**
-     * Gets the clamping threshold used to suppress estimation errors when applying specular
-     * anti-aliasing.
-     */
-    public float getSpecularAntiAliasingThreshold() {
-        return nGetSpecularAntiAliasingThreshold(getNativeObject());
-    }
-
     /**
      * Enables or disables double-sided lighting if the parent Material has double-sided capability,
      * otherwise prints a warning. If double-sided lighting is enabled, backface culling is
@@ -537,14 +419,6 @@ public class MaterialInstance {
         nSetDoubleSided(getNativeObject(), doubleSided);
     }
 
-    /**
-     * Returns whether double-sided lighting is enabled when the parent Material has double-sided
-     * capability.
-     */
-    public boolean isDoubleSided() {
-        return nIsDoubleSided(getNativeObject());
-    }
-
     /**
      * Overrides the default triangle culling state that was set on the material.
      *
@@ -552,18 +426,10 @@ public class MaterialInstance {
      * <a href="https://google.github.io/filament/Materials.html#materialdefinitions/materialblock/rasterization:culling">
      * Rasterization: culling</a>
      */
-    public void setCullingMode(@NonNull Material.CullingMode mode) {
+    public void setCullingMode(Material.CullingMode mode) {
         nSetCullingMode(getNativeObject(), mode.ordinal());
     }
 
-    /**
-     * Returns the face culling mode.
-     */
-    @NonNull
-    public Material.CullingMode getCullingMode() {
-        return sCullingModeValues[nGetCullingMode(getNativeObject())];
-    }
-
     /**
      * Overrides the default color-buffer write state that was set on the material.
      *
@@ -575,13 +441,6 @@ public class MaterialInstance {
         nSetColorWrite(getNativeObject(), enable);
     }
 
-    /**
-     * Returns whether color write is enabled.
-     */
-    public boolean isColorWriteEnabled() {
-        return nIsColorWriteEnabled(getNativeObject());
-    }
-
     /**
      * Overrides the default depth-buffer write state that was set on the material.
      *
@@ -593,27 +452,6 @@ public class MaterialInstance {
         nSetDepthWrite(getNativeObject(), enable);
     }
 
-    /**
-     * Returns whether depth write is enabled.
-     */
-    public boolean isDepthWriteEnabled() {
-        return nIsDepthWriteEnabled(getNativeObject());
-    }
-
-    /**
-     * Enables or Disable stencil writes
-     */
-    public void setStencilWrite(boolean enable) {
-        nSetStencilWrite(getNativeObject(), enable);
-    }
-
-    /**
-     * Returns whether stencil write is enabled.
-     */
-    public boolean isStencilWriteEnabled() {
-        return nIsStencilWriteEnabled(getNativeObject());
-    }
-
     /**
      * Overrides the default depth testing state that was set on the material.
      *
@@ -625,231 +463,6 @@ public class MaterialInstance {
         nSetDepthCulling(getNativeObject(), enable);
     }
 
-    /**
-     * Sets the depth comparison function (default is {@link TextureSampler.CompareFunction#GE}).
-     *
-     * @param func the depth comparison function
-     */
-    public void setDepthFunc(TextureSampler.CompareFunction func) {
-        nSetDepthFunc(getNativeObject(), func.ordinal());
-    }
-
-    /**
-     * Returns whether depth culling is enabled.
-     */
-    public boolean isDepthCullingEnabled() {
-        return nIsDepthCullingEnabled(getNativeObject());
-    }
-
-    /**
-     * Returns the depth comparison function.
-     */
-    public TextureSampler.CompareFunction getDepthFunc() {
-        return TextureSampler.EnumCache.sCompareFunctionValues[nGetDepthFunc(getNativeObject())];
-    }
-
-    /**
-     * Sets the stencil comparison function (default is {@link TextureSampler.CompareFunction#ALWAYS}).
-     *
-     * <p>
-     * It's possible to set separate stencil comparison functions; one for front-facing polygons,
-     * and one for back-facing polygons. The face parameter determines the comparison function(s)
-     * updated by this call.
-     * </p>
-     *
-     * @param func the stencil comparison function
-     * @param face the faces to update the comparison function for
-     */
-    public void setStencilCompareFunction(TextureSampler.CompareFunction func, StencilFace face) {
-        nSetStencilCompareFunction(getNativeObject(), func.ordinal(),
-                sStencilFaceMapping[face.ordinal()]);
-    }
-
-    /**
-     * Sets the stencil comparison function for both front and back-facing polygons.
-     * @see #setStencilCompareFunction(TextureSampler.CompareFunction, StencilFace)
-     */
-    public void setStencilCompareFunction(TextureSampler.CompareFunction func) {
-        setStencilCompareFunction(func, StencilFace.FRONT_AND_BACK);
-    }
-
-    /**
-     * Sets the stencil fail operation (default is {@link StencilOperation#KEEP}).
-     *
-     * <p>
-     * The stencil fail operation is performed to update values in the stencil buffer when the
-     * stencil test fails.
-     * </p>
-     *
-     * <p>
-     * It's possible to set separate stencil fail operations; one for front-facing polygons, and one
-     * for back-facing polygons. The face parameter determines the stencil fail operation(s) updated
-     * by this call.
-     * </p>
-     *
-     * @param op the stencil fail operation
-     * @param face the faces to update the stencil fail operation for
-     */
-    public void setStencilOpStencilFail(StencilOperation op, StencilFace face) {
-        nSetStencilOpStencilFail(getNativeObject(), op.ordinal(),
-                sStencilFaceMapping[face.ordinal()]);
-    }
-
-    /**
-     * Sets the stencil fail operation for both front and back-facing polygons.
-     * @see #setStencilOpStencilFail(StencilOperation, StencilFace)
-     */
-    public void setStencilOpStencilFail(StencilOperation op) {
-        setStencilOpStencilFail(op, StencilFace.FRONT_AND_BACK);
-    }
-
-    /**
-     * Sets the depth fail operation (default is {@link StencilOperation#KEEP}).
-     *
-     * <p>
-     * The depth fail operation is performed to update values in the stencil buffer when the depth
-     * test fails.
-     * </p>
-     *
-     * <p>
-     * It's possible to set separate depth fail operations; one for front-facing polygons, and one
-     * for back-facing polygons. The face parameter determines the depth fail operation(s) updated
-     * by this call.
-     * </p>
-     *
-     * @param op the depth fail operation
-     * @param face the faces to update the depth fail operation for
-     */
-    public void setStencilOpDepthFail(StencilOperation op, StencilFace face) {
-        nSetStencilOpDepthFail(getNativeObject(), op.ordinal(),
-                sStencilFaceMapping[face.ordinal()]);
-    }
-
-    /**
-     * Sets the depth fail operation for both front and back-facing polygons.
-     * @see #setStencilOpDepthFail(StencilOperation, StencilFace)
-     */
-    public void setStencilOpDepthFail(StencilOperation op) {
-        setStencilOpDepthFail(op, StencilFace.FRONT_AND_BACK);
-    }
-
-    /**
-     * Sets the depth-stencil pass operation (default is {@link StencilOperation#KEEP}).
-     *
-     * <p>
-     * The depth-stencil pass operation is performed to update values in the stencil buffer when
-     * both the stencil test and depth test pass.
-     * </p>
-     *
-     * <p>
-     * It's possible to set separate depth-stencil pass operations; one for front-facing polygons,
-     * and one for back-facing polygons. The face parameter determines the depth-stencil pass
-     * operation(s) updated by this call.
-     * </p>
-     *
-     * @param op the depth-stencil pass operation
-     * @param face the faces to update the depth-stencil operation for
-     */
-    public void setStencilOpDepthStencilPass(StencilOperation op, StencilFace face) {
-        nSetStencilOpDepthStencilPass(getNativeObject(), op.ordinal(),
-                sStencilFaceMapping[face.ordinal()]);
-    }
-
-    /**
-     * Sets the depth-stencil pass operation for both front and back-facing polygons.
-     * @see #setStencilOpDepthStencilPass(StencilOperation, StencilFace)
-     */
-    public void setStencilOpDepthStencilPass(StencilOperation op) {
-        setStencilOpDepthStencilPass(op, StencilFace.FRONT_AND_BACK);
-    }
-
-    /**
-     * Sets the stencil reference value (default is 0).
-     *
-     * <p>
-     * The stencil reference value is the left-hand side for stencil comparison tests. It's also
-     * used as the replacement stencil value when {@link StencilOperation} is
-     * {@link StencilOperation#REPLACE}.
-     * </p>
-     *
-     * <p>
-     * It's possible to set separate stencil reference values; one for front-facing polygons, and
-     * one for back-facing polygons. The face parameter determines the reference value(s) updated by
-     * this call.
-     * </p>
-     *
-     * @param value the stencil reference value (only the least significant 8 bits are used)
-     * @param face the faces to update the reference value for
-     */
-    public void setStencilReferenceValue(@IntRange(from = 0, to = 255) int value, StencilFace face) {
-        nSetStencilReferenceValue(getNativeObject(), value, sStencilFaceMapping[face.ordinal()]);
-    }
-
-    /**
-     * Sets the stencil reference value for both front and back-facing polygons.
-     * @see #setStencilReferenceValue(int, StencilFace)
-     */
-    public void setStencilReferenceValue(@IntRange(from = 0, to = 255) int value) {
-        setStencilReferenceValue(value, StencilFace.FRONT_AND_BACK);
-    }
-
-    /**
-     * Sets the stencil read mask (default is 0xFF).
-     *
-     * <p>
-     * The stencil read mask masks the bits of the values participating in the stencil comparison
-     * test- both the value read from the stencil buffer and the reference value.
-     * </p>
-     *
-     * <p>
-     * It's possible to set separate stencil read masks; one for front-facing polygons, and one for
-     * back-facing polygons. The face parameter determines the stencil read mask(s) updated by this
-     * call.
-     * </p>
-     *
-     * @param readMask the read mask (only the least significant 8 bits are used)
-     * @param face the faces to update the read mask for
-     */
-    public void setStencilReadMask(@IntRange(from = 0, to = 255) int readMask, StencilFace face) {
-        nSetStencilReadMask(getNativeObject(), readMask, sStencilFaceMapping[face.ordinal()]);
-    }
-
-    /**
-     * Sets the stencil read mask for both front and back-facing polygons.
-     * @see #setStencilReadMask(int, StencilFace)
-     */
-    public void setStencilReadMask(@IntRange(from = 0, to = 255) int readMask) {
-        setStencilReadMask(readMask, StencilFace.FRONT_AND_BACK);
-    }
-
-    /**
-     * Sets the stencil write mask (default is 0xFF).
-     *
-     * <p>
-     * The stencil write mask masks the bits in the stencil buffer updated by stencil operations.
-     * </p>
-     *
-     * <p>
-     * It's possible to set separate stencil write masks; one for front-facing polygons, and one for
-     * back-facing polygons. The face parameter determines the stencil write mask(s) updated by this
-     * call.
-     * </p>
-     *
-     * @param writeMask the write mask (only the least significant 8 bits are used)
-     * @param face the faces to update the read mask for
-     */
-    public void setStencilWriteMask(@IntRange(from = 0, to = 255) int writeMask, StencilFace face) {
-        nSetStencilWriteMask(getNativeObject(), writeMask, sStencilFaceMapping[face.ordinal()]);
-    }
-
-    /**
-     * Sets the stencil write mask for both front and back-facing polygons.
-     * @see #setStencilWriteMask(int, StencilFace)
-     */
-    public void setStencilWriteMask(int writeMask) {
-        setStencilWriteMask(writeMask, StencilFace.FRONT_AND_BACK);
-    }
-
     public long getNativeObject() {
         if (mNativeObject == 0) {
             throw new IllegalStateException("Calling method on destroyed MaterialInstance");
@@ -900,7 +513,7 @@ public class MaterialInstance {
             @IntRange(from = 0) int offset, @IntRange(from = 1) int count);
 
     private static native void nSetParameterTexture(long nativeMaterialInstance,
-            @NonNull String name, long nativeTexture, long sampler);
+            @NonNull String name, long nativeTexture, int sampler);
 
     private static native void nSetScissor(long nativeMaterialInstance,
             @IntRange(from = 0) int left, @IntRange(from = 0) int bottom,
@@ -922,39 +535,8 @@ public class MaterialInstance {
     private static native void nSetCullingMode(long nativeMaterialInstance, long mode);
     private static native void nSetColorWrite(long nativeMaterialInstance, boolean enable);
     private static native void nSetDepthWrite(long nativeMaterialInstance, boolean enable);
-    private static native void nSetStencilWrite(long nativeMaterialInstance, boolean enable);
     private static native void nSetDepthCulling(long nativeMaterialInstance, boolean enable);
-    private static native void nSetDepthFunc(long nativeMaterialInstance, long function);
-
-    private static native void nSetStencilCompareFunction(long nativeMaterialInstance,
-            long function, long face);
-    private static native void nSetStencilOpStencilFail(long nativeMaterialInstance, long op,
-            long face);
-    private static native void nSetStencilOpDepthFail(long nativeMaterialInstance, long op,
-            long face);
-    private static native void nSetStencilOpDepthStencilPass(long nativeMaterialInstance, long op,
-            long face);
-    private static native void nSetStencilReferenceValue(long nativeMaterialInstance, int value,
-            long face);
-    private static native void nSetStencilReadMask(long nativeMaterialInstance, int readMask,
-            long face);
-    private static native void nSetStencilWriteMask(long nativeMaterialInstance, int writeMask,
-            long face);
 
     private static native String nGetName(long nativeMaterialInstance);
     private static native long nGetMaterial(long nativeMaterialInstance);
-
-    private static native long nDuplicate(long otherNativeMaterialInstance, String name);
-
-
-    private static native float nGetMaskThreshold(long nativeMaterialInstance);
-    private static native float nGetSpecularAntiAliasingVariance(long nativeMaterialInstance);
-    private static native float nGetSpecularAntiAliasingThreshold(long nativeMaterialInstance);
-    private static native boolean nIsDoubleSided(long nativeMaterialInstance);
-    private static native int nGetCullingMode(long nativeMaterialInstance);
-    private static native boolean nIsColorWriteEnabled(long nativeMaterialInstance);
-    private static native boolean nIsDepthWriteEnabled(long nativeMaterialInstance);
-    private static native boolean nIsStencilWriteEnabled(long nativeMaterialInstance);
-    private static native boolean nIsDepthCullingEnabled(long nativeMaterialInstance);
-    private static native int nGetDepthFunc(long nativeMaterialInstance);
 }

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

@@ -1,180 +0,0 @@
-/*
- * Copyright (C) 2022 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 MorphTargetBuffer {
-    private long mNativeObject;
-    private MorphTargetBuffer(long nativeMorphTargetBuffer) {
-        mNativeObject = nativeMorphTargetBuffer;
-    }
-
-    public static class Builder {
-        @SuppressWarnings({"FieldCanBeLocal", "UnusedDeclaration"})
-        // Keep to finalize native resources
-        private final MorphTargetBuffer.Builder.BuilderFinalizer mFinalizer;
-        private final long mNativeBuilder;
-
-        public Builder() {
-            mNativeBuilder = nCreateBuilder();
-            mFinalizer = new MorphTargetBuffer.Builder.BuilderFinalizer(mNativeBuilder);
-        }
-
-        /**
-         * Size of the morph targets in vertex counts.
-         *
-         * @param vertexCount Number of vertex counts the morph targets can hold.
-         * @return this <code>Builder</code> object for chaining calls
-         */
-        @NonNull
-        public Builder vertexCount(@IntRange(from = 1) int vertexCount) {
-            nBuilderVertexCount(mNativeBuilder, vertexCount);
-            return this;
-        }
-
-        /**
-         * Size of the morph targets in targets.
-         *
-         * @param count Number of targets the morph targets can hold.
-         * @return this <code>Builder</code> object for chaining calls
-         */
-        @NonNull
-        public Builder count(@IntRange(from = 1) int count) {
-            nBuilderCount(mNativeBuilder, count);
-            return this;
-        }
-
-        /**
-         * Creates and returns the <code>MorphTargetBuffer</code> object.
-         *
-         * @param engine reference to the {@link Engine} to associate this <code>MorphTargetBuffer</code>
-         *               with.
-         *
-         * @return the newly created <code>MorphTargetBuffer</code> object
-         *
-         * @exception IllegalStateException if the MorphTargetBuffer could not be created
-         *
-         * @see #setMorphTargetBufferOffsetAt
-         */
-        @NonNull
-        public MorphTargetBuffer build(@NonNull Engine engine) {
-            long nativeMorphTargetBuffer = nBuilderBuild(mNativeBuilder, engine.getNativeObject());
-            if (nativeMorphTargetBuffer == 0)
-                throw new IllegalStateException("Couldn't create MorphTargetBuffer");
-            return new MorphTargetBuffer(nativeMorphTargetBuffer);
-        }
-
-        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 float4 positions for the given morph target.
-     *
-     * @param engine {@link Engine} instance
-     * @param targetIndex The index of morph target to be updated
-     * @param positions An array with at least count*4 floats
-     * @param count Number of float4 vectors in positions to be consumed
-     */
-    public void setPositionsAt(@NonNull Engine engine,
-            @IntRange(from = 0) int targetIndex,
-            @NonNull float[] positions, @IntRange(from = 0, to = 125) int count) {
-        int result = nSetPositionsAt(mNativeObject, engine.getNativeObject(), targetIndex,
-                positions, count);
-        if (result < 0) {
-            throw new BufferOverflowException();
-        }
-    }
-
-    /**
-     * Updates tangents for the given morph target.
-     *
-     * These quaternions must be represented as signed shorts, where real numbers in the [-1,+1]
-     * range multiplied by 32767.
-     *
-     * @param engine {@link Engine} instance
-     * @param targetIndex The index of morph target to be updated
-     * @param tangents An array with at least "count*4" shorts
-     * @param count number of short4 quaternions in tangents
-     */
-    public void setTangentsAt(@NonNull Engine engine,
-            @IntRange(from = 0) int targetIndex,
-            @NonNull short[] tangents, @IntRange(from = 0, to = 125) int count) {
-        int result = nSetTangentsAt(mNativeObject, engine.getNativeObject(), targetIndex,
-                tangents, count);
-        if (result < 0) {
-            throw new BufferOverflowException();
-        }
-    }
-
-    /**
-     * @return number of vertices in this {@link MorphTargetBuffer}
-     */
-    public int getVertexCount() {
-        return nGetVertexCount(mNativeObject);
-    }
-
-    /**
-     * @return number of morph targets in this {@link MorphTargetBuffer}
-     */
-    public int getCount() {
-        return nGetCount(mNativeObject);
-    }
-
-    public long getNativeObject() {
-        if (mNativeObject == 0) {
-            throw new IllegalStateException("Calling method on destroyed MorphTargetBuffer");
-        }
-        return mNativeObject;
-    }
-
-    void clearNativeObject() {
-        mNativeObject = 0;
-    }
-
-    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 nBuilderCount(long nativeBuilder, int count);
-    private static native long nBuilderBuild(long nativeBuilder, long nativeEngine);
-
-    private static native int nSetPositionsAt(long nativeObject, long nativeEngine, int targetIndex, float[] positions, int count);
-    private static native int nSetTangentsAt(long nativeObject, long nativeEngine, int targetIndex, short[] tangents, int count);
-    private static native int nGetVertexCount(long nativeObject);
-    private static native int nGetCount(long nativeObject);
-}

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

@@ -31,15 +31,13 @@ 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[ATTACHMENT_COUNT];
+    private final Texture[] mTextures = new Texture[2];
 
     private RenderTarget(long nativeRenderTarget, Builder builder) {
         mNativeObject = nativeRenderTarget;
-        System.arraycopy(builder.mTextures, 0, mTextures, 0, ATTACHMENT_COUNT);
+        mTextures[0] = builder.mTextures[0];
+        mTextures[1] = builder.mTextures[1];
     }
 
     public long getNativeObject() {
@@ -54,14 +52,7 @@ public class RenderTarget {
      */
     public enum AttachmentPoint {
         COLOR,
-        COLOR1,
-        COLOR2,
-        COLOR3,
-        COLOR4,
-        COLOR5,
-        COLOR6,
-        COLOR7,
-        DEPTH
+        DEPTH,
     }
 
     /**
@@ -71,7 +62,7 @@ public class RenderTarget {
         @SuppressWarnings({"FieldCanBeLocal", "UnusedDeclaration"})
         private final BuilderFinalizer mFinalizer;
         private final long mNativeBuilder;
-        private final Texture[] mTextures = new Texture[ATTACHMENT_COUNT];
+        private final Texture[] mTextures = new Texture[2];
 
         public Builder() {
             mNativeBuilder = nCreateBuilder();
@@ -81,6 +72,8 @@ public class RenderTarget {
         /**
          * Sets a texture to a given attachment point.
          *
+         * <p>All RenderTargets must have a non-null <code>COLOR</code> attachment.</p>
+         *
          * @param attachment The attachment point of the texture.
          * @param texture The associated texture object.
          * @return A reference to this Builder for chaining calls.
@@ -194,7 +187,7 @@ public class RenderTarget {
      * a cubemap.
      */
     public Texture.CubemapFace getFace(AttachmentPoint attachment) {
-        return sCubemapFaceValues[nGetFace(getNativeObject(), attachment.ordinal())];
+        return Texture.CubemapFace.values()[nGetFace(getNativeObject(), attachment.ordinal())];
     }
 
     /**

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

@@ -58,10 +58,6 @@ import java.util.Set;
  */
 public class RenderableManager {
     private static final String LOG_TAG = "Filament";
-
-    private static final VertexBuffer.VertexAttribute[] sVertexAttributeValues =
-            VertexBuffer.VertexAttribute.values();
-
     private long mNativeObject;
 
     RenderableManager(long nativeRenderableManager) {
@@ -96,9 +92,7 @@ public class RenderableManager {
     public enum PrimitiveType {
         POINTS(0),
         LINES(1),
-        LINE_STRIP(3),
-        TRIANGLES(4),
-        TRIANGLE_STRIP(5);
+        TRIANGLES(4);
 
         private final int mType;
         PrimitiveType(int value) { mType = value; }
@@ -119,7 +113,7 @@ public class RenderableManager {
          * @param count the number of primitives that will be supplied to the builder
          *
          * Note that builders typically do not have a long lifetime since clients should discard
-         * them after calling {@link #build}. For a usage example, see {@link RenderableManager}.
+         * them after calling build(). For a usage example, see {@link RenderableManager}.
          */
         public Builder(@IntRange(from = 1) int count) {
             mNativeBuilder = nCreateBuilder(count);
@@ -134,7 +128,7 @@ public class RenderableManager {
          * <code>geometry()</code> and <code>material()</code>.
          *
          * @param index zero-based index of the primitive, must be less than the count passed to Builder constructor
-         * @param type specifies the topology of the primitive (e.g., {@link PrimitiveType#TRIANGLES})
+         * @param type specifies the topology of the primitive (e.g., PrimitiveType.TRIANGLES)
          * @param vertices specifies the vertex buffer, which in turn specifies a set of attributes
          * @param indices specifies the index buffer (either u16 or u32)
          * @param offset specifies where in the index buffer to start reading (expressed as a number of indices)
@@ -153,7 +147,7 @@ public class RenderableManager {
         }
 
         /**
-         * For details, see the {@link RenderableManager.Builder#geometry} primary overload.
+         * For details, see the {@link RenderableManager.Builder#geometry primary overload}.
          */
         @NonNull
         public Builder geometry(@IntRange(from = 0) int index, @NonNull PrimitiveType type,
@@ -165,7 +159,7 @@ public class RenderableManager {
         }
 
         /**
-         * For details, see the {@link RenderableManager.Builder#geometry} primary overload.
+         * For details, see the {@link RenderableManager.Builder#geometry primary overload}.
          */
         @NonNull
         public Builder geometry(@IntRange(from = 0) int index, @NonNull PrimitiveType type,
@@ -175,32 +169,6 @@ public class RenderableManager {
             return this;
         }
 
-        /**
-         * Type of geometry for a Renderable
-         */
-        public enum GeometryType {
-            /** dynamic gemoetry has no restriction */
-            DYNAMIC,
-            /** bounds and world space transform are immutable */
-            STATIC_BOUNDS,
-            /** skinning/morphing not allowed and Vertex/IndexBuffer immutables */
-            STATIC
-        }
-
-        /**
-         * Specify whether this renderable has static bounds. In this context his means that
-         * the renderable's bounding box cannot change and that the renderable's transform is
-         * assumed immutable. Changing the renderable's transform via the TransformManager
-         * can lead to corrupted graphics. Note that skinning and morphing are not forbidden.
-         * Disabled by default.
-         * @param enable whether this renderable has static bounds. false by default.
-         */
-        @NonNull
-        public Builder geometryType(GeometryType type) {
-            nBuilderGeometryType(mNativeBuilder, type.ordinal());
-            return this;
-        }
-
         /**
          * Binds a material instance to the specified primitive.
          *
@@ -217,9 +185,7 @@ public class RenderableManager {
         }
 
         /**
-         * Sets the drawing order for blended primitives. The drawing order is either global or
-         * local (default) to this Renderable. In either case, the Renderable priority takes
-         * precedence.
+         * Sets an ordering index for blended primitives that all live at the same Z value.
          *
          * @param index the primitive of interest
          * @param blendOrder draw order number (0 by default). Only the lowest 15 bits are used.
@@ -231,18 +197,6 @@ public class RenderableManager {
             return this;
         }
 
-       /**
-         * Sets whether the blend order is global or local to this Renderable (by default).
-         *
-         * @param index the primitive of interest
-         * @param enabled true for global, false for local blend ordering.
-         */
-        @NonNull
-        public Builder globalBlendOrderEnabled(@IntRange(from = 0) int index, boolean enabled) {
-            nBuilderGlobalBlendOrderEnabled(mNativeBuilder, index, enabled);
-            return this;
-        }
-
         /**
          * The axis-aligned bounding box of the renderable.
          *
@@ -283,79 +237,23 @@ public class RenderableManager {
          * Provides coarse-grained control over draw order.
          *
          * <p>In general Filament reserves the right to re-order renderables to allow for efficient
-         * rendering. However clients can control ordering at a coarse level using \em priority.
-         * The priority is applied separately for opaque and translucent objects, that is, opaque
-         * objects are always drawn before translucent objects regardless of the priority.</p>
+         * rendering. However clients can control ordering at a coarse level using <em>priority</em>.</p>
          *
          * <p>For example, this could be used to draw a semitransparent HUD, if a client wishes to
          * avoid using a separate View for the HUD. Note that priority is completely orthogonal to
          * {@link Builder#layerMask}, which merely controls visibility.</p>
-
-         * <p>The Skybox always using the lowest priority, so it's drawn last, which may improve
-         * performance.</p>
          *
          * <p>The priority is clamped to the range [0..7], defaults to 4; 7 is lowest priority
          * (rendered last).</p>
          *
          * @see Builder#blendOrder
          */
-
-        /**
-         * Provides coarse-grained control over draw order.
-         *
-         * <p>In general Filament reserves the right to re-order renderables to allow for efficient
-         * rendering. However clients can control ordering at a coarse level using priority.
-         * The priority is applied separately for opaque and translucent objects, that is, opaque
-         * objects are always drawn before translucent objects regardless of the priority.</p>
-         *
-         * <p>For example, this could be used to draw a semitransparent HUD, if a client wishes to
-         * avoid using a separate View for the HUD. Note that priority is completely orthogonal to
-         * {@link Builder#layerMask}, which merely controls visibility.</p>
-
-         * <p>The Skybox always using the lowest priority, so it's drawn last, which may improve
-         * performance.</p>
-         *
-         * @param priority clamped to the range [0..7], defaults to 4; 7 is lowest priority
-         *                 (rendered last).
-         *
-         * @return Builder reference for chaining calls.
-         *
-         * @see Builder#channel
-         * @see Builder#blendOrder
-         * @see #setPriority
-         * @see #setBlendOrderAt
-         */
         @NonNull
         public Builder priority(@IntRange(from = 0, to = 7) int priority) {
             nBuilderPriority(mNativeBuilder, priority);
             return this;
         }
 
-        /**
-         * Set the channel this renderable is associated to. There can be 4 channels.
-         *
-         * <p>All renderables in a given channel are rendered together, regardless of anything else.
-         * They are sorted as usual within a channel.</p>
-         * <p>Channels work similarly to priorities, except that they enforce the strongest
-         * ordering.</p>
-         *
-         * <p>Channels 0 and 1 may not have render primitives using a material with `refractionType`
-         * set to `screenspace`.</p>
-         *
-         * @param channel clamped to the range [0..3], defaults to 2.
-         *
-         * @return Builder reference for chaining calls.
-         *
-         * @see Builder::blendOrder()
-         * @see Builder::priority()
-         * @see RenderableManager::setBlendOrderAt()
-         */
-        @NonNull
-        public Builder channel(@IntRange(from = 0, to = 3) int channel) {
-            nBuilderChannel(mNativeBuilder, channel);
-            return this;
-        }
-
         /**
          * Controls frustum culling, true by default.
          *
@@ -368,34 +266,6 @@ public class RenderableManager {
             return this;
         }
 
-        /**
-         * 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;
-        }
-
-        /**
-         * Specifies the number of draw instance of this renderable. The default is 1 instance and
-         * the maximum number of instances allowed is 32767. 0 is invalid.
-         * All instances are culled using the same bounding box, so care must be taken to make
-         * sure all instances render inside the specified bounding box.
-         * The material can use getInstanceIndex() in the vertex shader to get the instance index and
-         * possibly adjust the position or transform.
-         *
-         * @param instanceCount the number of instances silently clamped between 1 and 32767.
-         */
-        @NonNull
-        public Builder instances(@IntRange(from = 1, to = 32767) int instanceCount) {
-            nBuilderInstances(mNativeBuilder, instanceCount);
-            return this;
-        }
-
         /**
          * Controls if this renderable casts shadows, false by default.
          *
@@ -433,62 +303,6 @@ public class RenderableManager {
             return this;
         }
 
-        /**
-         * Allows bones to be swapped out and shared using SkinningBuffer.
-         *
-         * If skinning buffer mode is enabled, clients must call #setSkinningBuffer() rather than
-         * #setBonesAsQuaternions(). This allows sharing of data between renderables.
-         *
-         * @param enabled If true, enables buffer object mode.  False by default.
-         */
-        @NonNull
-        public Builder enableSkinningBuffers(boolean enabled) {
-            nBuilderEnableSkinningBuffers(mNativeBuilder, enabled);
-            return this;
-        }
-
-        /**
-         * Controls if this renderable is affected by the large-scale fog.
-         * @param enabled If true, enables large-scale fog on this object. Disables it otherwise.
-         *                True by default.
-         * @return this <code>Builder</code> object for chaining calls
-         */
-         @NonNull
-        public Builder fog(boolean enabled) {
-            nBuilderFog(mNativeBuilder, enabled);
-            return this;
-        }
-
-        /**
-         * Enables GPU vertex skinning for up to 255 bones, 0 by default.
-         *
-         *<p>Skinning Buffer mode must be enabled.</p>
-         *
-         *<p>Each vertex can be affected by up to 4 bones simultaneously. The attached
-         * VertexBuffer must provide data in the BONE_INDICES slot (uvec4) and the
-         * BONE_WEIGHTS slot (float4).</p>
-         *
-         *<p>See also {@link #setSkinningBuffer}, {@link SkinningBuffer#setBonesAsMatrices}
-         * or  {@link SkinningBuffer#setBonesAsQuaternions},
-         * which can be called on a per-frame basis to advance the animation.</p>
-         *
-         * @see #setSkinningBuffer
-         * @see SkinningBuffer#setBonesAsMatrices
-         * @see SkinningBuffer#setBonesAsQuaternions
-         *
-         * @param skinningBuffer null to disable, otherwise the {@link SkinningBuffer} to use
-         * @param boneCount 0 to disable, otherwise the number of bone transforms (up to 255)
-         * @param offset offset in the {@link SkinningBuffer}
-         * @return this <code>Builder</code> object for chaining calls
-         */
-        @NonNull
-        public Builder skinning(SkinningBuffer skinningBuffer,
-                @IntRange(from = 0, to = 255) int boneCount, int offset) {
-            nBuilderSkinningBuffer(mNativeBuilder,
-                    skinningBuffer != null ? skinningBuffer.getNativeObject() : 0, boneCount, offset);
-            return this;
-        }
-
         @NonNull
         public Builder skinning(@IntRange(from = 0, to = 255) int boneCount) {
             nBuilderSkinning(mNativeBuilder, boneCount);
@@ -498,8 +312,6 @@ public class RenderableManager {
         /**
          * Enables GPU vertex skinning for up to 255 bones, 0 by default.
          *
-         * <p>Skinning Buffer mode must be disabled.</p>
-         *
          * <p>Each vertex can be affected by up to 4 bones simultaneously. The attached
          * VertexBuffer must provide data in the <code>BONE_INDICES</code> slot (uvec4) and the
          * <code>BONE_WEIGHTS</code> slot (float4).</p>
@@ -507,8 +319,6 @@ public class RenderableManager {
          * <p>See also {@link RenderableManager#setBonesAsMatrices}, which can be called on a per-frame basis
          * to advance the animation.</p>
          *
-         * @see SkinningBuffer#setBonesAsMatrices
-         *
          * @param boneCount Number of bones associated with this component
          * @param bones A FloatBuffer containing boneCount transforms. Each transform consists of 8 float.
          *              float 0 to 3 encode a unit quaternion w+ix+jy+kz stored as x,y,z,w.
@@ -524,58 +334,17 @@ public class RenderableManager {
         }
 
         /**
-         * Controls if the renderable has legacy vertex morphing targets, zero by default.
+         * Controls if the renderable has vertex morphing targets, false by default.
          *
-         * For legacy morphing, the attached {@link VertexBuffer} must provide data in the
-         * appropriate {@link VertexBuffer.VertexAttribute} slots (<code>MORPH_POSITION_0</code> etc).
-         * Legacy morphing only supports up to 4 morph targets and will be deprecated in the future.
-         * Legacy morphing must be enabled on the material definition: either via the
-         * <code>legacyMorphing</code> material attribute or by calling
-         * {@link MaterialBuilder::useLegacyMorphing}.
+         * <p>This is required to enable GPU morphing for up to 4 attributes. The attached VertexBuffer
+         * must provide data in the appropriate VertexAttribute slots (<code>MORPH_POSITION_0</code> etc).</p>
          *
          * <p>See also {@link RenderableManager#setMorphWeights}, which can be called on a per-frame basis
          * to advance the animation.</p>
          */
         @NonNull
-        public Builder morphing(@IntRange(from = 0, to = 255) int targetCount) {
-            nBuilderMorphing(mNativeBuilder, targetCount);
-            return this;
-        }
-
-        /**
-         * Controls if the renderable has vertex morphing targets, zero by default.
-         *
-         * <p>For standard morphing, A {@link MorphTargetBuffer} must be provided.
-         * Standard morphing supports up to
-         * <code>CONFIG_MAX_MORPH_TARGET_COUNT</code> morph targets.</p>
-         *
-         * <p>See also {@link RenderableManager#setMorphWeights}, which can be called on a per-frame basis
-         * to advance the animation.</p>
-         */
-        @NonNull
-        public Builder morphing(@NonNull MorphTargetBuffer morphTargetBuffer) {
-            nBuilderMorphingStandard(mNativeBuilder, morphTargetBuffer.getNativeObject());
-            return this;
-        }
-
-        /**
-         * Specifies the morph target buffer for a primitive.
-         *
-         * The morph target buffer must have an associated renderable and geometry. Two conditions
-         * must be met:
-         * 1. The number of morph targets in the buffer must equal the renderable's morph target
-         *    count.
-         * 2. The vertex count of each morph target must equal the geometry's vertex count.
-         *
-         * @param level the level of detail (lod), only 0 can be specified
-         * @param primitiveIndex zero-based index of the primitive, must be less than the count passed to Builder constructor
-         * @param offset specifies where in the morph target buffer to start reading (expressed as a number of vertices)
-         */
-        @NonNull
-        public Builder morphing(@IntRange(from = 0) int level,
-                                @IntRange(from = 0) int primitiveIndex,
-                                @IntRange(from = 0) int offset) {
-            nBuilderSetMorphTargetBufferOffsetAt(mNativeBuilder, level, primitiveIndex, offset);
+        public Builder morphing(boolean enabled) {
+            nBuilderMorphing(mNativeBuilder, enabled);
             return this;
         }
 
@@ -610,22 +379,9 @@ public class RenderableManager {
         }
     }
 
-
-    /**
-     * Associates a {@link SkinningBuffer} to a renderable instance
-     * @param i Instance of the Renderable
-     * @param skinningBuffer {@link SkinningBuffer} to use
-     * @param count Numbers of bones to set
-     * @param offset Offset in the {@link SkinningBuffer}
-     */
-    public void setSkinningBuffer(@EntityInstance int i, @NonNull SkinningBuffer skinningBuffer,
-                           int count, int offset) {
-        nSetSkinningBuffer(mNativeObject, i, skinningBuffer.getNativeObject(), count, offset);
-    }
-
     /**
      * Sets the transforms associated with each bone of a Renderable.
-     *
+    *
      * @param i Instance of the Renderable
      * @param matrices A FloatBuffer containing boneCount 4x4 packed matrices (i.e. 16 floats each matrix and no gap between matrices)
      * @param boneCount Number of bones to set
@@ -662,35 +418,15 @@ public class RenderableManager {
     /**
      * Updates the vertex morphing weights on a renderable, all zeroes by default.
      *
-     * <p>The renderable must be built with morphing enabled. In legacy morphing mode, only the
-     * first 4 weights are considered.</p>
-     *
-     * @see Builder#morphing
-     */
-    public void setMorphWeights(@EntityInstance int i, @NonNull float[] weights, @IntRange(from = 0) int offset) {
-        nSetMorphWeights(mNativeObject, i, weights, offset);
-    }
-
-    /**
-     * Changes the morph target buffer for the given primitive.
+     * <p>This is specified using a 4-tuple, one float per morph target. If the renderable has fewer
+     * than 4 morph targets, then clients should fill the unused components with zeroes.</p>
      *
      * <p>The renderable must be built with morphing enabled.</p>
      *
      * @see Builder#morphing
      */
-    public void setMorphTargetBufferOffsetAt(@EntityInstance int i,
-                                       @IntRange(from = 0) int level,
-                                       @IntRange(from = 0) int primitiveIndex,
-                                       @IntRange(from = 0) int offset) {
-        nSetMorphTargetBufferOffsetAt(mNativeObject, i, level, primitiveIndex, 0, offset);
-    }
-
-    /**
-     * Gets the morph target count on a renderable.
-     */
-    @IntRange(from = 0)
-    public int getMorphTargetCount(@EntityInstance int i) {
-        return nGetMorphTargetCount(mNativeObject, i);
+    public void setMorphWeights(@EntityInstance int i, @NonNull @Size(min = 4) float[] weights) {
+        nSetMorphWeights(mNativeObject, i, weights);
     }
 
     /**
@@ -725,15 +461,6 @@ public class RenderableManager {
         nSetPriority(mNativeObject, i, priority);
     }
 
-    /**
-     * Changes the channel of a renderable
-     *
-     * @see Builder#channel
-     */
-    public void setChannel(@EntityInstance int i, @IntRange(from = 0, to = 3) int channel) {
-        nSetChannel(mNativeObject, i, channel);
-    }
-
     /**
      * Changes whether or not frustum culling is on.
      *
@@ -743,47 +470,6 @@ public class RenderableManager {
         nSetCulling(mNativeObject, i, enabled);
     }
 
-    /**
-     * Changes whether or not the large-scale fog is applied to this renderable
-     * @see Builder#fog
-     */
-    public void setFogEnabled(@EntityInstance int i, boolean enabled) {
-        nSetFogEnabled(mNativeObject, i, enabled);
-    }
-
-    /**
-     * Returns whether large-scale fog is enabled for this renderable.
-     * @return True if fog is enabled for this renderable.
-     * @see Builder#fog
-     */
-    public boolean getFogEnabled(@EntityInstance int i) {
-        return nGetFogEnabled(mNativeObject, i);
-    }
-
-    /**
-     * 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);
-    }
-
     /**
      * Changes whether or not the renderable casts shadows.
      *
@@ -902,9 +588,18 @@ public class RenderableManager {
                 0, indices.getIndexCount());
     }
 
-     /**
-     * Changes the drawing order for blended primitives. The drawing order is either global or
-     * local (default) to this Renderable. In either case, the Renderable priority takes precedence.
+    /**
+     * Changes the geometry for the given primitive.
+     *
+     * @see Builder#geometry Builder.geometry
+     */
+    public void setGeometryAt(@EntityInstance int i, @IntRange(from = 0) int primitiveIndex,
+            @NonNull PrimitiveType type, @IntRange(from = 0) int offset, @IntRange(from = 0) int count) {
+        nSetGeometryAt(mNativeObject, i, primitiveIndex, type.getValue(), offset, count);
+    }
+
+    /**
+     * Changes the ordering index for blended primitives that all live at the same Z value.
      *
      * @see Builder#blendOrder
      *
@@ -917,36 +612,18 @@ public class RenderableManager {
         nSetBlendOrderAt(mNativeObject, instance, primitiveIndex, blendOrder);
     }
 
-    /**
-     * Changes whether the blend order is global or local to this Renderable (by default).
-     *
-     * @see Builder#globalBlendOrderEnabled
-     *
-     * @param instance the renderable of interest
-     * @param primitiveIndex the primitive of interest
-     * @param enabled true for global, false for local blend ordering.
-     */
-    public void setGlobalBlendOrderEnabledAt(@EntityInstance int instance, @IntRange(from = 0) int primitiveIndex,
-            boolean enabled) {
-        nSetGlobalBlendOrderEnabledAt(mNativeObject, instance, primitiveIndex, enabled);
-    }
-
     /**
      * Retrieves the set of enabled attribute slots in the given primitive's VertexBuffer.
      */
-    public Set<VertexBuffer.VertexAttribute> getEnabledAttributesAt(
-            @EntityInstance int i, @IntRange(from = 0) int primitiveIndex) {
+    public Set<VertexBuffer.VertexAttribute> getEnabledAttributesAt(@EntityInstance int i, @IntRange(from = 0) int primitiveIndex) {
         int bitSet = nGetEnabledAttributesAt(mNativeObject, i, primitiveIndex);
-        Set<VertexBuffer.VertexAttribute> requiredAttributes =
-                EnumSet.noneOf(VertexBuffer.VertexAttribute.class);
-        VertexBuffer.VertexAttribute[] values = sVertexAttributeValues;
-
+        Set<VertexBuffer.VertexAttribute> requiredAttributes = EnumSet.noneOf(VertexBuffer.VertexAttribute.class);
+        VertexBuffer.VertexAttribute[] values = VertexBuffer.VertexAttribute.values();
         for (int j = 0; j < values.length; j++) {
             if ((bitSet & (1 << j)) != 0) {
                 requiredAttributes.add(values[j]);
             }
         }
-
         requiredAttributes = Collections.unmodifiableSet(requiredAttributes);
         return requiredAttributes;
     }
@@ -966,44 +643,26 @@ public class RenderableManager {
     private static native void nBuilderGeometry(long nativeBuilder, int index, int value, long nativeVertexBuffer, long nativeIndexBuffer);
     private static native void nBuilderGeometry(long nativeBuilder, int index, int value, long nativeVertexBuffer, long nativeIndexBuffer, int offset, int count);
     private static native void nBuilderGeometry(long nativeBuilder, int index, int value, long nativeVertexBuffer, long nativeIndexBuffer, int offset, int minIndex, int maxIndex, int count);
-    private static native void nBuilderGeometryType(long nativeBuilder, int type);
     private static native void nBuilderMaterial(long nativeBuilder, int index, long nativeMaterialInstance);
     private static native void nBuilderBlendOrder(long nativeBuilder, int index, int blendOrder);
-    private static native void nBuilderGlobalBlendOrderEnabled(long nativeBuilder, int index, boolean enabled);
     private static native void nBuilderBoundingBox(long nativeBuilder, float cx, float cy, float cz, float ex, float ey, float ez);
     private static native void nBuilderLayerMask(long nativeBuilder, int select, int value);
     private static native void nBuilderPriority(long nativeBuilder, int priority);
-    private static native void nBuilderChannel(long nativeBuilder, int channel);
     private static native void nBuilderCulling(long nativeBuilder, boolean enabled);
     private static native void nBuilderCastShadows(long nativeBuilder, boolean enabled);
     private static native void nBuilderReceiveShadows(long nativeBuilder, boolean enabled);
     private static native void nBuilderScreenSpaceContactShadows(long nativeBuilder, boolean enabled);
     private static native void nBuilderSkinning(long nativeBuilder, int boneCount);
     private static native int nBuilderSkinningBones(long nativeBuilder, int boneCount, Buffer bones, int remaining);
-    private static native void nBuilderSkinningBuffer(long nativeBuilder, long nativeSkinningBuffer, int boneCount, int offset);
-    private static native void nBuilderMorphing(long nativeBuilder, int targetCount);
-    private static native void nBuilderMorphingStandard(long nativeBuilder, long nativeMorphTargetBuffer);
-    private static native void nBuilderSetMorphTargetBufferOffsetAt(long nativeBuilder, int level, int primitiveIndex, int offset);
-    private static native void nBuilderEnableSkinningBuffers(long nativeBuilder, boolean enabled);
-    private static native void nBuilderFog(long nativeBuilder, boolean enabled);
-    private static native void nBuilderLightChannel(long nativeRenderableManager, int channel, boolean enable);
-    private static native void nBuilderInstances(long nativeRenderableManager, int instances);
+    private static native void nBuilderMorphing(long nativeBuilder, boolean enabled);
 
-    private static native void nSetSkinningBuffer(long nativeObject, int i, long nativeSkinningBuffer, int count, int offset);
     private static native int nSetBonesAsMatrices(long nativeObject, int i, Buffer matrices, int remaining, int boneCount, int offset);
     private static native int nSetBonesAsQuaternions(long nativeObject, int i, Buffer quaternions, int remaining, int boneCount, int offset);
-    private static native void nSetMorphWeights(long nativeObject, int instance, float[] weights, int offset);
-    private static native void nSetMorphTargetBufferOffsetAt(long nativeObject, int i, int level, int primitiveIndex, long nativeMorphTargetBuffer, int offset);
-    private static native int nGetMorphTargetCount(long nativeObject, int i);
+    private static native void nSetMorphWeights(long nativeObject, int instance, float[] weights);
     private static native void nSetAxisAlignedBoundingBox(long nativeRenderableManager, int i, float cx, float cy, float cz, float ex, float ey, float ez);
     private static native void nSetLayerMask(long nativeRenderableManager, int i, int select, int value);
     private static native void nSetPriority(long nativeRenderableManager, int i, int priority);
-    private static native void nSetChannel(long nativeRenderableManager, int i, int channel);
     private static native void nSetCulling(long nativeRenderableManager, int i, boolean enabled);
-    private static native void nSetFogEnabled(long nativeRenderableManager, int i, boolean enabled);
-    private static native boolean nGetFogEnabled(long nativeRenderableManager, int i);
-    private static native void nSetLightChannel(long nativeRenderableManager, int i, int channel, boolean enable);
-    private static native boolean nGetLightChannel(long nativeRenderableManager, int i, int channel);
     private static native void nSetCastShadows(long nativeRenderableManager, int i, boolean enabled);
     private static native void nSetReceiveShadows(long nativeRenderableManager, int i, boolean enabled);
     private static native void nSetScreenSpaceContactShadows(long nativeRenderableManager, int i, boolean enabled);
@@ -1013,8 +672,9 @@ public class RenderableManager {
     private static native int nGetPrimitiveCount(long nativeRenderableManager, int i);
     private static native void nSetMaterialInstanceAt(long nativeRenderableManager, int i, int primitiveIndex, long nativeMaterialInstance);
     private static native long nGetMaterialInstanceAt(long nativeRenderableManager, int i, int primitiveIndex);
+    private static native long nGetMaterialAt(long nativeRenderableManager, int i, int primitiveIndex);
     private static native void nSetGeometryAt(long nativeRenderableManager, int i, int primitiveIndex, int primitiveType, long nativeVertexBuffer, long nativeIndexBuffer, int offset, int count);
+    private static native void nSetGeometryAt(long nativeRenderableManager, int i, int primitiveIndex, int primitiveType, int offset, int count);
     private static native void nSetBlendOrderAt(long nativeRenderableManager, int i, int primitiveIndex, int blendOrder);
-    private static native void nSetGlobalBlendOrderEnabledAt(long nativeRenderableManager, int i, int primitiveIndex, boolean enabled);
     private static native int nGetEnabledAttributesAt(long nativeRenderableManager, int i, int primitiveIndex);
 }

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

@@ -61,17 +61,13 @@ public class Renderer {
         /**
          * How far in advance a buffer must be queued for presentation at a given time in ns
          * On Android you can use {@link android.view.Display#getPresentationDeadlineNanos()}.
-         * @deprecated this value is ignored
          */
-        @Deprecated
         public long presentationDeadlineNanos = 0;
 
         /**
          * Offset by which vsyncSteadyClockTimeNano provided in beginFrame() is offset in ns
          * On Android you can use {@link android.view.Display#getAppVsyncOffsetNanos()}.
-         * @deprecated this value is ignored
          */
-        @Deprecated
         public long vsyncOffsetNanos = 0;
     };
 
@@ -101,7 +97,7 @@ public class Renderer {
         /**
          * Desired frame interval in unit of 1 / DisplayInfo.refreshRate.
          */
-        public float interval = 1.0f;
+        public float interval = 1.0f / 60.0f;
 
         /**
          * Additional headroom for the GPU as a ratio of the targetFrameTime.
@@ -111,12 +107,12 @@ public class Renderer {
         /**
          * Rate at which the scale will change to reach the target frame rate.
          */
-        public float scaleRate = 1.0f / 15.0f;
+        public float scaleRate = 0.125f;
 
         /**
-         * History size. higher values, tend to filter more (clamped to 31).
+         * History size. higher values, tend to filter more (clamped to 30).
          */
-        public int history = 15;
+        public int history = 9;
     }
 
     /**
@@ -124,24 +120,7 @@ public class Renderer {
      */
     public static class ClearOptions {
         /**
-         * Color (sRGB linear) to use to clear the RenderTarget (typically the SwapChain).
-         *
-         * The RenderTarget is cleared using this color, which won't be tone-mapped since
-         * tone-mapping is part of View rendering (this is not).
-         *
-         * When a View is rendered, there are 3 scenarios to consider:
-         * - Pixels rendered by the View replace the clear color (or blend with it in
-         *   `BlendMode.TRANSLUCENT` mode).
-         *
-         * - With blending mode set to `BlendMode.TRANSLUCENT`, Pixels untouched by the View
-         *   are considered fulling transparent and let the clear color show through.
-         *
-         * - With blending mode set to `BlendMode.OPAQUE`, Pixels untouched by the View
-         *   are set to the clear color. However, because it is now used in the context of a View,
-         *   it will go through the post-processing stage, which includes tone-mapping.
-         *
-         * For consistency, it is recommended to always use a Skybox to clear an opaque View's
-         * background, or to use black or fully-transparent (i.e. {0,0,0,0}) as the clear color.
+         * Color to use to clear the SwapChain
          */
         @NonNull
         public float[] clearColor = { 0.0f, 0.0f, 0.0f, 0.0f };
@@ -196,7 +175,8 @@ public class Renderer {
      */
     public void setDisplayInfo(@NonNull DisplayInfo info) {
         mDisplayInfo = info;
-        nSetDisplayInfo(getNativeObject(), info.refreshRate);
+        nSetDisplayInfo(getNativeObject(),
+                info.refreshRate, info.presentationDeadlineNanos, info.vsyncOffsetNanos);
     }
 
     /**
@@ -267,50 +247,6 @@ public class Renderer {
         return mEngine;
     }
 
-    /**
-     * Set the time at which the frame must be presented to the display.
-     * <p>
-     * This must be called between {@link #beginFrame} and {@link #endFrame}.
-     * </p>
-     *
-     * @param monotonicClockNanos  The time in nanoseconds corresponding to the system monotonic
-     *                             up-time clock. The presentation time is typically set in the
-     *                             middle of the period of interest and cannot be too far in the
-     *                             future as it is limited by how many buffers are available in
-     *                             the display sub-system. Typically it is set to 1 or 2 vsync
-     *                             periods away.
-     */
-    public void setPresentationTime(long monotonicClockNanos) {
-        nSetPresentationTime(getNativeObject(), monotonicClockNanos);
-    }
-
-    /**
-     * The use of this method is optional. It sets the VSYNC time expressed as the duration in
-     * nanosecond since epoch of std::chrono::steady_clock.
-     * If called, passing 0 to frameTimeNanos in Renderer.BeginFrame will use this
-     * time instead.
-     * @param steadyClockTimeNano duration in nanosecond since epoch of std::chrono::steady_clock
-     * @see Engine#getSteadyClockTimeNano
-     * @see Renderer#beginFrame
-     */
-    public void setVsyncTime(long steadyClockTimeNano) {
-        nSetVsyncTime(getNativeObject(), steadyClockTimeNano);
-    }
-
-    /**
-     * Call skipFrame when momentarily skipping frames, for instance if the content of the
-     * scene doesn't change.
-     *
-     * @param vsyncSteadyClockTimeNano The time in nanoseconds when the frame started being rendered,
-     *                       in the {@link System#nanoTime()} timebase. Divide this value by 1000000 to
-     *                       convert it to the {@link android.os.SystemClock#uptimeMillis()}
-     *                       time base. This typically comes from
-     *                       {@link android.view.Choreographer.FrameCallback}.
-     */
-    public void skipFrame(long vsyncSteadyClockTimeNano) {
-        nSkipFrame(getNativeObject(), vsyncSteadyClockTimeNano);
-    }
-
     /**
      * Sets up a frame for this <code>Renderer</code>.
      * <p><code>beginFrame</code> manages frame pacing, and returns whether or not a frame should be
@@ -373,13 +309,13 @@ public class Renderer {
      *
      * <p><code>render()</code> generates commands for each of the following stages:</p>
      * <ul>
-     * <li>Shadow map passes, if needed</li>
+     * <li>Shadow map pass, if needed (currently only a single shadow map is supported)</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>
@@ -395,58 +331,31 @@ 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.
@@ -501,9 +410,8 @@ public class Renderer {
      *</pre>
      *
      *
-     * <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>
+     * <p>Typically <code>readPixels</code> will be called after {@link #render} and before
+     * {@link #endFrame}.</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.
@@ -595,10 +503,6 @@ public class Renderer {
      * Typically, this will happen after multiple calls to {@link #beginFrame},
      * {@link #render}, {@link #endFrame}.</p>
      * <br>
-     * <p>OpenGL only: if issuing a <code>readPixels</code> on a {@link RenderTarget} backed by a
-     * {@link Texture} that had data uploaded to it via {@link Texture#setImage}, the data returned
-     * from <code>readPixels</code> will be y-flipped with respect to the {@link Texture#setImage}
-     * call.</p>
      * <p><code>readPixels</code> is intended for debugging and testing.
      * It will impact performance significantly.</p>
      *
@@ -728,13 +632,9 @@ public class Renderer {
         mNativeObject = 0;
     }
 
-    private static native void nSetPresentationTime(long nativeObject, long monotonicClockNanos);
-    private static native void nSetVsyncTime(long nativeObject, long steadyClockTimeNano);
-    private static native void nSkipFrame(long nativeObject, long vsyncSteadyClockTimeNano);
     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,
@@ -752,7 +652,8 @@ public class Renderer {
             Object handler, Runnable callback);
     private static native double nGetUserTime(long nativeRenderer);
     private static native void nResetUserTime(long nativeRenderer);
-    private static native void nSetDisplayInfo(long nativeRenderer, float refreshRate);
+    private static native void nSetDisplayInfo(long nativeRenderer,
+            float refreshRate, long presentationDeadlineNanos, long vsyncOffsetNanos);
     private static native void nSetFrameRateOptions(long nativeRenderer,
             float interval, float headRoomRatio, float scaleRate, int history);
     private static native void nSetClearOptions(long nativeRenderer,

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

@@ -16,7 +16,6 @@
 
 package com.google.android.filament;
 
-import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 
 /**
@@ -129,7 +128,6 @@ public class Scene {
     /**
      * @deprecated See {@link #removeEntity(int)}
      */
-    @Deprecated
     public void remove(@Entity int entity) {
         removeEntity(entity);
     }
@@ -147,43 +145,23 @@ public class Scene {
     }
 
     /**
-     * Returns the total number of Entities in the <code>Scene</code>, whether alive or not.
+     * Returns the number of {@link RenderableManager} components in the <code>Scene</code>.
      *
-     * @return the total number of Entities in the <code>Scene</code>.
-     */
-    public int getEntityCount() {
-        return nGetEntityCount(getNativeObject());
-    }
-
-    /**
-     * Returns the number of active (alive) {@link RenderableManager} components in the
-     * <code>Scene</code>.
-     *
-     * @return number of {@link RenderableManager} components in the <code>Scene</code>.
+     * @return number of {@link RenderableManager} components in the <code>Scene</code>..
      */
     public int getRenderableCount() {
         return nGetRenderableCount(getNativeObject());
     }
 
     /**
-     * Returns the number of active (alive) {@link LightManager} components in the
-     * <code>Scene</code>.
+     * Returns the number of {@link LightManager} components in the <code>Scene</code>.
      *
-     * @return number of {@link LightManager} components in the <code>Scene</code>.
+     * @return number of {@link LightManager} components in the <code>Scene</code>..
      */
     public int getLightCount() {
         return nGetLightCount(getNativeObject());
     }
 
-    /**
-     * Returns true if the given entity is in the Scene.
-     *
-     * @return Whether the given entity is in the Scene.
-     */
-    public boolean hasEntity(@Entity int entity) {
-        return nHasEntity(getNativeObject(), entity);
-    }
-
     public long getNativeObject() {
         if (mNativeObject == 0) {
             throw new IllegalStateException("Calling method on destroyed Scene");
@@ -191,52 +169,6 @@ public class Scene {
         return mNativeObject;
     }
 
-    /**
-     * Returns the list of all entities in the Scene. If outArray is provided and large enough,
-     * it is used to store the list and returned, otherwise a new array is allocated and returned.
-     * @param outArray an array to store the list of entities in the scene.
-     * @return outArray if it was used or a newly allocated array.
-     * @see #getEntityCount
-     */
-    public int[] getEntities(@Nullable int[] outArray) {
-        int c = getEntityCount();
-        if (outArray == null || outArray.length < c) {
-            outArray = new int[c];
-        }
-        boolean success = nGetEntities(getNativeObject(), outArray, outArray.length);
-        if (!success) {
-            throw new IllegalStateException("Error retriving Scene's entities");
-        }
-        return outArray;
-    }
-
-    /**
-     * Returns the list of all entities in the Scene in a newly allocated array.
-     * @return an array containing the list of all entities in the scene.
-     * @see #getEntityCount
-     */
-    public int[] getEntities() {
-        return getEntities(null);
-    }
-
-    public interface EntityProcessor {
-        void process(@Entity int entity);
-    }
-
-    /**
-     * Invokes user functor on each entity in the scene.
-     *
-     * It is not allowed to add or remove an entity from the scene within the functor.
-     *
-     * @param entityProcessor User provided functor called for each entity in the scene
-     */
-    public void forEach(@NonNull EntityProcessor entityProcessor) {
-        int[] entities = getEntities(null);
-        for (int entity : entities) {
-            entityProcessor.process(entity);
-        }
-    }
-
     void clearNativeObject() {
         mNativeObject = 0;
     }
@@ -247,9 +179,6 @@ public class Scene {
     private static native void nAddEntities(long nativeScene, int[] entities);
     private static native void nRemove(long nativeScene, int entity);
     private static native void nRemoveEntities(long nativeScene, int[] entities);
-    private static native int nGetEntityCount(long nativeScene);
     private static native int nGetRenderableCount(long nativeScene);
     private static native int nGetLightCount(long nativeScene);
-    private static native boolean nHasEntity(long nativeScene, int entity);
-    private static native boolean nGetEntities(long nativeScene, int[] outArray, int length);
 }

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

@@ -1,177 +0,0 @@
-/*
- * 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

@@ -51,7 +51,11 @@ import static com.google.android.filament.Colors.LinearColor;
 public class Skybox {
     private long mNativeObject;
 
-    public Skybox(long nativeSkybox) {
+    public Skybox(Engine engine, long nativeSkybox) {
+        mNativeObject = nativeSkybox;
+    }
+
+    Skybox(long nativeSkybox) {
         mNativeObject = nativeSkybox;
     }
 
@@ -109,11 +113,10 @@ public class Skybox {
         }
 
         /**
-         * Sets the <code>Skybox</code> intensity when no {@link IndirectLight} is set on the
-         * {@link Scene}.
+         * Sets the <code>Skybox</code> intensity when no {@link IndirectLight} is set
          *
-         * <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>
+         * <p>This call is ignored when an  {@link IndirectLight} is set, otherwise it is used in
+         * its place.</p>
          *
          * @param envIntensity  Scale factor applied to the skybox texel values such that
          *                      the result is in <i>lux</i>, or <i>lumen/m^2</i> (default = 30000)

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

@@ -29,6 +29,7 @@ import java.nio.ReadOnlyBufferException;
  * 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>
@@ -65,6 +66,12 @@ import java.nio.ReadOnlyBufferException;
  * </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.
@@ -84,8 +91,6 @@ import java.nio.ReadOnlyBufferException;
  * @see Engine#destroyStream
  */
 public class Stream {
-    private static final StreamType[] sStreamTypeValues = StreamType.values();
-
     private long mNativeObject;
     private long mNativeEngine;
 
@@ -96,6 +101,9 @@ public class Stream {
         /** Not synchronized but copy-free. Good for video. */
         NATIVE,
 
+        /** Synchronized, but GL-only and incurs copies. Good for AR on devices before API 26. */
+        TEXTURE_ID,
+
         /** Synchronized, copy-free, and take a release callback. Good for AR but requires API 26+. */
         ACQUIRED,
     };
@@ -111,7 +119,8 @@ public class Stream {
      * By default, Stream objects are {@link StreamType#ACQUIRED ACQUIRED} and must have external images pushed to them via
      * {@link #setAcquiredImage}.
      *
-     * To create a {@link StreamType#NATIVE NATIVE} stream, call the <pre>stream</pre> method on the builder.
+     * To create a {@link StreamType#NATIVE NATIVE} or {@link StreamType#TEXTURE_ID TEXTURE_ID} stream, call one of the <pre>stream</pre> methods
+     * on the builder.
      */
     public static class Builder {
         @SuppressWarnings({"FieldCanBeLocal", "UnusedDeclaration"}) // Keep to finalize native resources
@@ -145,6 +154,25 @@ public class Stream {
             throw new IllegalArgumentException("Invalid stream source: " + streamSource);
         }
 
+        /**
+         * Creates a {@link StreamType#TEXTURE_ID TEXTURE_ID} stream. A copy stream will sample data from the supplied
+         * external texture and copy it into an internal private texture.
+         *
+         * <p>Currently only OpenGL external texture ids are supported.</p>
+         *
+         * @param externalTextureId An opaque texture id (typically a GLuint created with
+         *                          <code>glGenTextures()</code>) in a context shared with
+         *                          filament -- in that case this texture's target must be
+         *                          <code>GL_TEXTURE_EXTERNAL_OES.</code>
+         * @return This Builder, for chaining calls.
+         * @see Texture#setExternalStream
+         */
+        @NonNull
+        public Builder stream(long externalTextureId) {
+            nBuilderStream(mNativeBuilder, externalTextureId);
+            return this;
+        }
+
         /**
          * @param width initial width of the incoming stream. Whether this value is used is
          *              stream dependent. On Android, it must be set when using
@@ -203,10 +231,10 @@ public class Stream {
     }
 
     /**
-     * Indicates whether this <code>Stream</code> is NATIVE or ACQUIRED.
+     * Indicates whether this <code>Stream</code> is NATIVE, TEXTURE_ID, or ACQUIRED.
      */
     public StreamType getStreamType() {
-        return sStreamTypeValues[nGetStreamType(getNativeObject())];
+        return StreamType.values()[nGetStreamType(getNativeObject())];
     }
 
     /**
@@ -222,7 +250,7 @@ public class Stream {
      * 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 and ACQUIRED configurations.
+     * 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}.
@@ -244,6 +272,92 @@ public class Stream {
         nSetDimensions(getNativeObject(), width, height);
     }
 
+    /**
+     * Reads back the content of the last frame of a <code>Stream</code> since the last call to
+     * {@link Renderer#beginFrame}.
+     *
+     * <p>The Stream must be a copy stream, which can be checked with {@link #getStreamType()}.
+     * This function is a no-op otherwise.</p>
+     *
+     * <pre>
+     *
+     *  Stream buffer                  User buffer (PixelBufferDescriptor)
+     *  +--------------------+
+     *  |                    |                .stride         .alignment
+     *  |                    |         ----------------------->-->
+     *  |                    |         O----------------------+--+   low addresses
+     *  |                    |         |          |           |  |
+     *  |             w      |         |          | .top      |  |
+     *  |       <--------->  |         |          V           |  |
+     *  |       +---------+  |         |     +---------+      |  |
+     *  |       |     ^   |  | ======> |     |         |      |  |
+     *  |   x   |    h|   |  |         |.left|         |      |  |
+     *  +------>|     v   |  |         +---->|         |      |  |
+     *  |       +.........+  |         |     +.........+      |  |
+     *  |            ^       |         |                      |  |
+     *  |          y |       |         +----------------------+--+  high addresses
+     *  O------------+-------+
+     *
+     * </pre>
+     *
+     * <p>Typically readPixels() will be called after {@link Renderer#beginFrame}.</p>
+     *
+     * <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.
+     * Typically, this will happen after multiple calls to {@link Renderer#beginFrame},
+     * {@link Renderer#render}, {@link Renderer#endFrame}.</p>
+     *
+     * <p><code>readPixels</code> is intended for debugging and testing.
+     * It will impact performance significantly.</p>
+     *
+     * @param xoffset   left offset of the sub-region to read back
+     * @param yoffset   bottom offset of the sub-region to read back
+     * @param width     width of the sub-region to read back
+     * @param height    height of the sub-region to read back
+     * @param buffer    client-side buffer where the read-back will be written
+     *
+     *                  <p>
+     *                  The following format are always supported:
+     *                      <li>{@link Texture.Format#RGBA}</li>
+     *                      <li>{@link Texture.Format#RGBA_INTEGER}</li>
+     *                  </p>
+     *
+     *                  <p>
+     *                  The following types are always supported:
+     *                      <li>{@link Texture.Type#UBYTE}</li>
+     *                      <li>{@link Texture.Type#UINT}</li>
+     *                      <li>{@link Texture.Type#INT}</li>
+     *                      <li>{@link Texture.Type#FLOAT}</li>
+     *                  </p>
+     *
+     *                  <p>Other combination of format/type may be supported. If a combination is
+     *                  not supported, this operation may fail silently. Use a DEBUG build
+     *                  to get some logs about the failure.</p>
+     *
+     * @exception BufferOverflowException if the specified parameters would result in reading
+     * outside of <code>buffer</code>.
+     */
+    public void readPixels(
+            @IntRange(from = 0) int xoffset, @IntRange(from = 0) int yoffset,
+            @IntRange(from = 0) int width, @IntRange(from = 0) int height,
+            @NonNull Texture.PixelBufferDescriptor buffer) {
+
+        if (buffer.storage.isReadOnly()) {
+            throw new ReadOnlyBufferException();
+        }
+
+        int result = nReadPixels(getNativeObject(), mNativeEngine,
+                xoffset, yoffset, width, height,
+                buffer.storage, buffer.storage.remaining(),
+                buffer.left, buffer.top, buffer.type.ordinal(), buffer.alignment,
+                buffer.stride, buffer.format.ordinal(),
+                buffer.handler, buffer.callback);
+
+        if (result < 0) {
+            throw new BufferOverflowException();
+        }
+    }
+
     /**
      * Returns the presentation time of the currently displayed frame in nanosecond.
      *
@@ -269,6 +383,7 @@ public class Stream {
     private static native long nCreateBuilder();
     private static native void nDestroyBuilder(long nativeStreamBuilder);
     private static native void nBuilderStreamSource(long nativeStreamBuilder, Object streamSource);
+    private static native void nBuilderStream(long nativeStreamBuilder, long externalTextureId);
     private static native void nBuilderWidth(long nativeStreamBuilder, int width);
     private static native void nBuilderHeight(long nativeStreamBuilder, int height);
     private static native long nBuilderBuild(long nativeStreamBuilder, long nativeEngine);

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

@@ -68,35 +68,34 @@ public class SwapChain {
     private final Object mSurface;
     private long mNativeObject;
 
+    public static final long CONFIG_DEFAULT = 0x0;
+
+    /**
+     * This flag indicates that the <code>SwapChain</code> must be allocated with an
+     * alpha-channel.
+     */
+    public static final long CONFIG_TRANSPARENT = 0x1;
+
+    /**
+     * This flag indicates that the <code>SwapChain</code> may be used as a source surface
+     * for reading back render results.  This config must be set when creating
+     * any <code>SwapChain</code>  that will be used as the source for a blit operation.
+     *
+     * @see Renderer#copyFrame
+     */
+    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;
     }
 
-    /**
-     * Return whether createSwapChain supports the CONFIG_PROTECTED_CONTENT flag.
-     * The default implementation returns false.
-     *
-     * @param engine A reference to the filament Engine
-     * @return true if CONFIG_PROTECTED_CONTENT is supported, false otherwise.
-     * @see SwapChainFlags#CONFIG_PROTECTED_CONTENT
-     */
-    public static boolean isProtectedContentSupported(@NonNull Engine engine) {
-        return nIsProtectedContentSupported(engine.getNativeObject());
-    }
-
-    /**
-     * Return whether createSwapChain supports the CONFIG_SRGB_COLORSPACE flag.
-     * The default implementation returns false.
-     *
-     * @param engine A reference to the filament Engine
-     * @return true if CONFIG_SRGB_COLORSPACE is supported, false otherwise.
-     * @see SwapChainFlags#CONFIG_SRGB_COLORSPACE
-     */
-    public static boolean isSRGBSwapChainSupported(@NonNull Engine engine) {
-        return nIsSRGBSwapChainSupported(engine.getNativeObject());
-    }
-
     /**
      * @return the native <code>Object</code> this <code>SwapChain</code> was created from or null
      *         for a headless SwapChain.
@@ -115,6 +114,10 @@ public class SwapChain {
      * </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>
@@ -138,6 +141,4 @@ public class SwapChain {
     }
 
     private static native void nSetFrameCompletedCallback(long nativeSwapChain, Object handler, Runnable callback);
-    private static native boolean nIsSRGBSwapChainSupported(long nativeEngine);
-    private static native boolean nIsProtectedContentSupported(long nativeEngine);
 }

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

@@ -1,97 +0,0 @@
-/*
- * Copyright (C) 2024 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.google.android.filament;
-
-// Note: SwapChainFlags is kept separate from SwapChain so that UiHelper does not need to depend
-// on SwapChain. This allows clients to use UiHelper without requiring all of Filament's Java
-// classes.
-
-/**
- * Flags that a <code>SwapChain</code> can be created with to control behavior.
- *
- * @see Engine#createSwapChain
- * @see Engine#createSwapChainFromNativeSurface
- */
-public final class SwapChainFlags {
-
-    public static final long CONFIG_DEFAULT = 0x0;
-
-    /**
-     * This flag indicates that the <code>SwapChain</code> must be allocated with an
-     * alpha-channel.
-     */
-    public static final long CONFIG_TRANSPARENT = 0x1;
-
-    /**
-     * This flag indicates that the <code>SwapChain</code> may be used as a source surface
-     * for reading back render results.  This config must be set when creating
-     * any <code>SwapChain</code>  that will be used as the source for a blit operation.
-     *
-     * @see Renderer#copyFrame
-     */
-    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;
-
-    /**
-     * Indicates that the SwapChain must automatically perform linear to sRGB encoding.
-     *
-     * This flag is ignored if isSRGBSwapChainSupported() is false.
-     *
-     * When using this flag, post-processing should be disabled.
-     *
-     * @see SwapChain#isSRGBSwapChainSupported
-     * @see View#setPostProcessingEnabled
-     */
-    public static final long CONFIG_SRGB_COLORSPACE = 0x10;
-
-    /**
-     * Indicates that this SwapChain should allocate a stencil buffer in addition to a depth buffer.
-     *
-     * This flag is necessary when using View::setStencilBufferEnabled and rendering directly into
-     * the SwapChain (when post-processing is disabled).
-     *
-     * The specific format of the stencil buffer depends on platform support. The following pixel
-     * formats are tried, in order of preference:
-     *
-     * Depth only (without CONFIG_HAS_STENCIL_BUFFER):
-     * - DEPTH32F
-     * - DEPTH24
-     *
-     * Depth + stencil (with CONFIG_HAS_STENCIL_BUFFER):
-     * - DEPTH32F_STENCIL8
-     * - DEPTH24F_STENCIL8
-     *
-     * Note that enabling the stencil buffer may hinder depth precision and should only be used if
-     * necessary.
-     *
-     * @see View#setStencilBufferEnabled
-     * @see View#setPostProcessingEnabled
-     */
-    public static final long CONFIG_HAS_STENCIL_BUFFER = 0x20;
-
-    /**
-     * The SwapChain contains protected content. Only supported when isProtectedContentSupported()
-     * is true.
-     */
-    public static final long CONFIG_PROTECTED_CONTENT   = 0x40;
-}
-

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

@@ -71,12 +71,13 @@ 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;
 
-    public Texture(long nativeTexture) {
+    Texture(long nativeTexture) {
+        mNativeObject = nativeTexture;
+    }
+
+    public Texture(Engine engine, long nativeTexture) {
         mNativeObject = nativeTexture;
     }
 
@@ -219,50 +220,7 @@ public class Texture {
         ETC2_EAC_RGBA8, ETC2_EAC_SRGBA8,
 
         // Available everywhere except Android/iOS
-        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,
-
-        // RGTC formats available with a GLES extension
-        RED_RGTC1,              // BC4 unsigned
-        SIGNED_RED_RGTC1,       // BC4 signed
-        RED_GREEN_RGTC2,        // BC5 unsigned
-        SIGNED_RED_GREEN_RGTC2, // BC5 signed
-
-        // BPTC formats available with a GLES extension
-        RGB_BPTC_SIGNED_FLOAT,  // BC6H signed
-        RGB_BPTC_UNSIGNED_FLOAT,// BC6H unsigned
-        RGBA_BPTC_UNORM,        // BC7
-        SRGB_ALPHA_BPTC_UNORM   // BC7 sRGB
+        DXT1_RGB, DXT1_RGBA, DXT3_RGBA, DXT5_RGBA
     }
 
     /**
@@ -277,50 +235,7 @@ public class Texture {
         ETC2_EAC_RGBA8, ETC2_EAC_SRGBA8,
 
         // Available everywhere except Android/iOS
-        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,
-
-        // RGTC formats available with a GLES extension
-        RED_RGTC1,              // BC4 unsigned
-        SIGNED_RED_RGTC1,       // BC4 signed
-        RED_GREEN_RGTC2,        // BC5 unsigned
-        SIGNED_RED_GREEN_RGTC2, // BC5 signed
-
-        // BPTC formats available with a GLES extension
-        RGB_BPTC_SIGNED_FLOAT,  // BC6H signed
-        RGB_BPTC_UNSIGNED_FLOAT,// BC6H unsigned
-        RGBA_BPTC_UNORM,        // BC7
-        SRGB_ALPHA_BPTC_UNORM   // BC7 sRGB
+        DXT1_RGB, DXT1_RGBA, DXT3_RGBA, DXT5_RGBA
     }
 
     /**
@@ -566,7 +481,7 @@ public class Texture {
          * @param alignment     Alignment in bytes.
          * @return              Size of the buffer in bytes.
          */
-        public static int computeDataSize(@NonNull Format format, @NonNull Type type,
+        static int computeDataSize(@NonNull Format format, @NonNull Type type,
                 int stride, int height, @IntRange(from = 1, to = 8) int alignment) {
             if (type == Type.COMPRESSED) {
                 return 0;
@@ -594,15 +509,12 @@ 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:
@@ -780,26 +692,6 @@ 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.
@@ -849,10 +741,6 @@ public class Texture {
         public static final int SAMPLEABLE = 0x10;
         /** Texture can be used as a subpass input */
         public static final int SUBPASS_INPUT = 0x20;
-        /** Texture can be used the source of a blit() */
-        public static final int BLIT_SRC = 0x40;
-        /** Texture can be used the destination of a blit() */
-        public static final int BLIT_DST = 0x80;
         /** by default textures are <code>UPLOADABLE</code> and <code>SAMPLEABLE</code>*/
         public static final int DEFAULT = UPLOADABLE | SAMPLEABLE;
     }
@@ -898,7 +786,7 @@ public class Texture {
      */
     @NonNull
     public Sampler getTarget() {
-        return sSamplerValues[nGetTarget(getNativeObject())];
+        return Sampler.values()[nGetTarget(getNativeObject())];
     }
 
     /**
@@ -906,13 +794,13 @@ public class Texture {
      */
     @NonNull
     public InternalFormat getFormat() {
-        return sInternalFormatValues[nGetInternalFormat(getNativeObject())];
+        return InternalFormat.values()[nGetInternalFormat(getNativeObject())];
     }
 
     // TODO: add a setImage() version that takes an android Bitmap
 
     /**
-     * <code>setImage</code> is used to modify the whole content of the texture from a CPU-buffer.
+     * <code>setImage</code> is used to modify the whole content of the texure from a CPU-buffer.
      *
      *  <p>This <code>Texture</code> instance must use {@link Sampler#SAMPLER_2D SAMPLER_2D} or
      *  {@link Sampler#SAMPLER_EXTERNAL SAMPLER_EXTERNAL}. If the later is specified
@@ -940,7 +828,7 @@ public class Texture {
     public void setImage(@NonNull Engine engine,
             @IntRange(from = 0) int level,
             @NonNull PixelBufferDescriptor buffer) {
-        setImage(engine, level, 0, 0, 0, getWidth(level), getHeight(level), 1, buffer);
+        setImage(engine, level, 0, 0, getWidth(level), getHeight(level), buffer);
     }
 
 
@@ -975,22 +863,40 @@ public class Texture {
             @IntRange(from = 0) int xoffset, @IntRange(from = 0) int yoffset,
             @IntRange(from = 0) int width, @IntRange(from = 0) int height,
             @NonNull PixelBufferDescriptor buffer) {
-        setImage(engine, level, xoffset, yoffset, 0, width, height, 1, buffer);
+        int result;
+        if (buffer.type == COMPRESSED) {
+            result = nSetImageCompressed(getNativeObject(), engine.getNativeObject(), level,
+                    xoffset, yoffset, width, height,
+                    buffer.storage, buffer.storage.remaining(),
+                    buffer.left, buffer.top, buffer.type.ordinal(), buffer.alignment,
+                    buffer.compressedSizeInBytes, buffer.compressedFormat.ordinal(),
+                    buffer.handler, buffer.callback);
+        } else {
+            result = nSetImage(getNativeObject(), engine.getNativeObject(), level,
+                    xoffset, yoffset, width, height,
+                    buffer.storage, buffer.storage.remaining(),
+                    buffer.left, buffer.top, buffer.type.ordinal(), buffer.alignment,
+                    buffer.stride, buffer.format.ordinal(),
+                    buffer.handler, buffer.callback);
+        }
+        if (result < 0) {
+            throw new BufferOverflowException();
+        }
     }
 
     /**
-     * <code>setImage</code> is used to modify a sub-region of a 3D texture, 2D texture array or
-     * cubemap from a CPU-buffer. Cubemaps are treated like a 2D array of six layers.
+     * <code>setImage</code> is used to modify a sub-region of the 3D texture or 2D texture array
+     * from a CPU-buffer.
      *
-     *  <p>This <code>Texture</code> instance must use {@link Sampler#SAMPLER_2D_ARRAY SAMPLER_2D_ARRAY},
-     *  {@link Sampler#SAMPLER_3D SAMPLER_3D} or {@link Sampler#SAMPLER_CUBEMAP SAMPLER_CUBEMAP}.</p>
+     *  <p>This <code>Texture</code> instance must use {@link Sampler#SAMPLER_2D_ARRAY SAMPLER_2D_ARRAY} or
+     *  {@link Sampler#SAMPLER_3D SAMPLER_3D}.</p>
      *
      * @param engine    {@link Engine} this texture is associated to. Must be the
      *                  instance passed to {@link Builder#build Builder.build()}.
      * @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 zoffset   z-offset in texel of the region to modify
+     * @param yoffset   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
@@ -1056,9 +962,7 @@ public class Texture {
      *
      * @see Builder#sampler
      * @see PixelBufferDescriptor
-     * @deprecated use {@link #setImage(Engine, int, int, int, int, int, int, int, PixelBufferDescriptor)}
      */
-     @Deprecated
     public void setImage(@NonNull Engine engine, @IntRange(from = 0) int level,
             @NonNull PixelBufferDescriptor buffer,
             @NonNull @Size(min = 6) int[] faceOffsetsInBytes) {
@@ -1260,7 +1164,6 @@ 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);
@@ -1270,6 +1173,18 @@ public class Texture {
     private static native int nGetTarget(long nativeTexture);
     private static native int nGetInternalFormat(long nativeTexture);
 
+    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 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 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 top, int type, int alignment,

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

@@ -22,14 +22,6 @@ 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.
@@ -126,7 +118,7 @@ public class TextureSampler {
         NEVER
     }
 
-    long mSampler = 0; // bit field used by native
+    int mSampler = 0; // bit field used by native
 
     /**
      * Initializes the <code>TextureSampler</code> with default values.
@@ -210,7 +202,7 @@ public class TextureSampler {
      * @return the minification filter
      */
     public MinFilter getMinFilter() {
-        return EnumCache.sMinFilterValues[nGetMinFilter(mSampler)];
+        return MinFilter.values()[nGetMinFilter(mSampler)];
     }
 
     /**
@@ -226,7 +218,7 @@ public class TextureSampler {
      * @return the magnification filter
      */
     public MagFilter getMagFilter() {
-        return EnumCache.sMagFilterValues[nGetMagFilter(mSampler)];
+        return MagFilter.values()[nGetMagFilter(mSampler)];
     }
 
     /**
@@ -242,7 +234,7 @@ public class TextureSampler {
      * @return the wrapping mode in the s (horizontal) direction
      */
     public WrapMode getWrapModeS() {
-        return EnumCache.sWrapModeValues[nGetWrapModeS(mSampler)];
+        return WrapMode.values()[nGetWrapModeS(mSampler)];
     }
 
     /**
@@ -257,7 +249,7 @@ public class TextureSampler {
      * @return the wrapping mode in the t (vertical) direction
      */
     public WrapMode getWrapModeT() {
-        return EnumCache.sWrapModeValues[nGetWrapModeT(mSampler)];
+        return WrapMode.values()[nGetWrapModeT(mSampler)];
     }
 
     /**
@@ -272,11 +264,11 @@ public class TextureSampler {
      * @return the wrapping mode in the r (depth) direction
      */
     public WrapMode getWrapModeR() {
-        return EnumCache.sWrapModeValues[nGetWrapModeR(mSampler)];
+        return WrapMode.values()[nGetWrapModeR(mSampler)];
     }
 
     /**
-     * Sets the wrapping mode in the r (depth) direction.
+     * Sets the wrapping mode in the t (depth) direction.
      * @param mode wrapping mode
      */
     public void setWrapModeR(WrapMode mode) {
@@ -305,7 +297,7 @@ public class TextureSampler {
      * @return the comparison mode
      */
     public CompareMode getCompareMode() {
-        return EnumCache.sCompareModeValues[nGetCompareMode(mSampler)];
+        return CompareMode.values()[nGetCompareMode(mSampler)];
     }
 
     /**
@@ -321,7 +313,7 @@ public class TextureSampler {
      * @return the comparison function
      */
     public CompareFunction getCompareFunction() {
-        return EnumCache.sCompareFunctionValues[nGetCompareFunction(mSampler)];
+        return CompareFunction.values()[nGetCompareFunction(mSampler)];
     }
 
     /**
@@ -342,26 +334,26 @@ public class TextureSampler {
         }
     }
 
-    private static native long nCreateSampler(int min, int max, int s, int t, int r);
-    private static native long nCreateCompareSampler(int mode, int function);
+    private static native int nCreateSampler(int min, int max, int s, int t, int r);
+    private static native int nCreateCompareSampler(int mode, int function);
 
-    private static native int nGetMinFilter(long sampler);
-    private static native long nSetMinFilter(long sampler, int filter);
-    private static native int nGetMagFilter(long sampler);
-    private static native long nSetMagFilter(long sampler, int filter);
+    private static native int nGetMinFilter(int sampler);
+    private static native int nSetMinFilter(int sampler, int filter);
+    private static native int nGetMagFilter(int sampler);
+    private static native int nSetMagFilter(int sampler, int filter);
 
-    private static native int nGetWrapModeS(long sampler);
-    private static native long nSetWrapModeS(long sampler, int mode);
-    private static native int nGetWrapModeT(long sampler);
-    private static native long nSetWrapModeT(long sampler, int mode);
-    private static native int nGetWrapModeR(long sampler);
-    private static native long nSetWrapModeR(long sampler, int mode);
+    private static native int nGetWrapModeS(int sampler);
+    private static native int nSetWrapModeS(int sampler, int mode);
+    private static native int nGetWrapModeT(int sampler);
+    private static native int nSetWrapModeT(int sampler, int mode);
+    private static native int nGetWrapModeR(int sampler);
+    private static native int nSetWrapModeR(int sampler, int mode);
 
-    private static native int nGetCompareMode(long sampler);
-    private static native long nSetCompareMode(long sampler, int mode);
-    private static native int nGetCompareFunction(long sampler);
-    private static native long nSetCompareFunction(long sampler, int function);
+    private static native int nGetCompareMode(int sampler);
+    private static native int nSetCompareMode(int sampler, int mode);
+    private static native int nGetCompareFunction(int sampler);
+    private static native int nSetCompareFunction(int sampler, int function);
 
-    private static native float nGetAnisotropy(long sampler);
-    private static native long nSetAnisotropy(long sampler, float anisotropy);
+    private static native float nGetAnisotropy(int sampler);
+    private static native int nSetAnisotropy(int sampler, float anisotropy);
 }

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

@@ -1,263 +0,0 @@
-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>
- *   <li>AgXToneMapper</li>
- * </ul>
- * <li>Fixed-aesthetic tone mapping operators</li>
- * <ul>
- *   <li>ACESToneMapper</li>
- *   <li>ACESLegacyToneMapper</li>
- *   <li>FilmicToneMapper</li>
- *   <li>PBRNeutralToneMapper</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());
-        }
-    }
-
-    /**
-     * Khronos PBR Neutral tone mapping operator. This tone mapper was designed
-     * to preserve the appearance of materials across lighting conditions while
-     * avoiding artifacts in the highlights in high dynamic range conditions.
-     */
-    public static class PBRNeutralToneMapper extends ToneMapper {
-        public PBRNeutralToneMapper() {
-            super(nCreatePBRNeutralToneMapper());
-        }
-    }
-
-    /**
-     * AgX tone mapping operator.
-     */
-    public static class Agx extends ToneMapper {
-        public enum AgxLook {
-            /**
-             * Base contrast with no look applied
-             */
-            NONE,
-
-            /**
-             * A punchy and more chroma laden look for sRGB displays
-             */
-            PUNCHY,
-
-            /**
-             * A golden tinted, slightly washed look for BT.1886 displays
-             */
-            GOLDEN
-        }
-
-        /**
-         * Builds a new AgX tone mapper with no look applied.
-         */
-        public Agx() {
-            this(AgxLook.NONE);
-        }
-
-        /**
-         * Builds a new AgX tone mapper.
-         *
-         * @param look: an optional creative adjustment to contrast and saturation
-         */
-        public Agx(AgxLook look) {
-            super(nCreateAgxToneMapper(look.ordinal()));
-        }
-    }
-
-    /**
-     * 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 nCreatePBRNeutralToneMapper();
-    private static native long nCreateAgxToneMapper(int look);
-    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

@@ -16,7 +16,6 @@
 
 package com.google.android.filament;
 
-import androidx.annotation.IntRange;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.annotation.Size;
@@ -84,35 +83,6 @@ 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.
@@ -144,23 +114,6 @@ 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.
      *
@@ -200,36 +153,6 @@ import androidx.annotation.Size;
         return nGetParent(mNativeObject, i);
     }
 
-    /**
-     * Returns the number of children of an {@link EntityInstance}.
-     *
-     * @param i the {@link EntityInstance} of the transform component to query.
-     * @return The number of children of the queried component.
-     */
-    public int getChildCount(@EntityInstance int i) {
-        return nGetChildCount(mNativeObject, i);
-    }
-
-    /**
-     * Gets a list of children for a transform component.
-     *
-     * @param i           the {@link EntityInstance} of the transform component to get the children
-     *                    from.
-     * @param outEntities array to receive the result sized to the maximum number of children to
-     *                    retrieve. If <code>null</code> is given, a new suitable array sized to
-     *                    {@link #getChildCount(int)} is allocated.
-     * @return Array of retrieved children {@link Entity}.
-     */
-    public @Entity @NonNull int[] getChildren(@EntityInstance int i, @Nullable int[] outEntities) {
-        if (outEntities == null) {
-            outEntities = new int[getChildCount(i)];
-        }
-        if (outEntities.length > 0) {
-            nGetChildren(mNativeObject, i, outEntities, outEntities.length);
-        }
-        return outEntities;
-    }
-
     /**
      * Sets a local transform of a transform component.
      * <p>This operation can be slow if the hierarchy of transform is too deep, and this
@@ -247,24 +170,6 @@ 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.
      *
@@ -285,26 +190,6 @@ 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.
      *
@@ -325,26 +210,6 @@ 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.
@@ -387,20 +252,12 @@ 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 int nGetChildCount(long nativeTransformManager, int i);
-    private static native void nGetChildren(long nativeEntityManager, int i, int[] outEntities, int count);
     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

@@ -104,6 +104,48 @@ 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
@@ -387,6 +429,38 @@ public class VertexBuffer {
                 bufferObject.getNativeObject());
     }
 
+    /**
+     * Convenience function that consumes normal vectors (and, optionally, tangent vectors) and
+     * produces quaternions that can be passed into a TANGENTS buffer.
+     *
+     * <p>
+     * The given output buffer must be preallocated with at least quatCount * outStride bytes.
+     * <p>
+     *
+     * <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
+     */
+    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 long getNativeObject() {
         if (mNativeObject == 0) {
             throw new IllegalStateException("Calling method on destroyed VertexBuffer");
@@ -416,4 +490,8 @@ public class VertexBuffer {
 
     private static native void nSetBufferObjectAt(long nativeVertexBuffer, long nativeEngine,
             int bufferIndex, long nativeBufferObject);
+
+    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);
 }

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

@@ -157,6 +157,8 @@ public class DisplayHelper {
             info = new Renderer.DisplayInfo();
         }
         info.refreshRate = DisplayHelper.getRefreshRate(display);
+        info.presentationDeadlineNanos = DisplayHelper.getPresentationDeadlineNanos(display);
+        info.vsyncOffsetNanos = DisplayHelper.getAppVsyncOffsetNanos(display);
         return info;
     }
 

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

@@ -1,60 +0,0 @@
-/*
- * Copyright (C) 2023 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.android;
-
-import com.google.android.filament.Engine;
-import com.google.android.filament.Fence;
-
-public class FilamentHelper {
-
-    /**
-     * Wait for all pending frames to be processed before returning. This is to avoid a race
-     * between the surface being resized before pending frames are rendered into it.
-     * <p>
-     * For {@link android.view.TextureView} this must be called before the texture's size is
-     * reconfigured, which unfortunately is done by the Android framework before
-     * {@link UiHelper} listeners are invoked. Therefore <code>synchronizePendingFrames</code>
-     * cannot be called from
-     * {@link android.view.TextureView.SurfaceTextureListener#onSurfaceTextureSizeChanged}; instead
-     * a subclass of {@link android.view.TextureView} must be used in order to call it from
-     * {@link android.view.TextureView#onSizeChanged}:
-     * </p>
-     * <pre>
-     * public class MyTextureView extends TextureView {
-     *     private Engine engine;
-     *     protected void onSizeChanged(int w, int h, int oldw, int oldh) {
-     *         FilamentHelper.synchronizePendingFrames(engine);
-     *         super.onSizeChanged(w, h, oldw, oldh);
-     *     }
-     * }
-     * </pre>
-     *
-     * Otherwise, this is typically called from {@link UiHelper.RendererCallback#onResized},
-     * {@link android.view.SurfaceHolder.Callback#surfaceChanged}.
-     *
-     * @param engine Filament engine to synchronize
-     *
-     * @see UiHelper.RendererCallback#onResized
-     * @see android.view.SurfaceHolder.Callback#surfaceChanged
-     * @see android.view.TextureView#onSizeChanged
-     */
-    static public void synchronizePendingFrames(Engine engine) {
-        Fence fence = engine.createFence();
-        fence.wait(Fence.Mode.FLUSH, Fence.WAIT_FOR_EVER);
-        engine.destroyFence(fence);
-    }
-}