add external sampler example

android/build.gradle

@@ -94,7 +94,7 @@ buildscript {
 
     ext.versions = [
         'jdk': 17,
-        'minSdk': 21,
+        'minSdk': 26,
         'targetSdk': 34,
         'compileSdk': 34,
         'kotlin': '2.0.21',
@@ -125,7 +125,7 @@ buildscript {
     ext.cmakeArgs = [
         "--no-warn-unused-cli",
         "-DANDROID_PIE=ON",
-        "-DANDROID_PLATFORM=21",
+        "-DANDROID_PLATFORM=26",
         "-DANDROID_STL=c++_static",
         "-DFILAMENT_DIST_DIR=${filamentPath}".toString(),
         "-DFILAMENT_SUPPORTS_VULKAN=${excludeVulkan ? 'OFF' : 'ON'}".toString(),
@@ -200,7 +200,7 @@ subprojects {
             ndkVersion versions.ndk
 
             defaultConfig {
-                minSdkVersion versions.minSdk
+                minSdkVersion 26
                 targetSdkVersion versions.targetSdk
 
                 externalNativeBuild {

android/filament-utils-android/CMakeLists.txt

@@ -4,6 +4,8 @@ project(filament-utils-android)
 set(FILAMENT_DIR ${FILAMENT_DIST_DIR})
 set(IMAGEIO_DIR ../../libs/imageio)
 
+set(CMAKE_SYSTEM_VERSION 26)
+
 add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/../gltfio-android ${CMAKE_CURRENT_BINARY_DIR}/gltfio-android)
 
 add_library(camutils STATIC IMPORTED)
@@ -30,6 +32,10 @@ add_library(iblprefilter STATIC IMPORTED)
 set_target_properties(iblprefilter PROPERTIES IMPORTED_LOCATION
         ${FILAMENT_DIR}/lib/${ANDROID_ABI}/libfilament-iblprefilter.a)
 
+add_library(bluevk STATIC IMPORTED)
+set_target_properties(bluevk PROPERTIES IMPORTED_LOCATION
+        ${FILAMENT_DIR}/lib/${ANDROID_ABI}/libbluevk.a)
+
 set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} -Wl,--version-script=${CMAKE_CURRENT_SOURCE_DIR}/libfilament-utils-jni.map")
 set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-z,max-page-size=16384")
 
@@ -57,7 +63,8 @@ target_include_directories(filament-utils-jni PRIVATE
         ..
         ../../filament/backend/include
         ${IMAGEIO_DIR}/include
-        ../../libs/utils/include)
+        ../../libs/utils/include
+        ../../libs/bluevk/include)
 
 set_target_properties(filament-utils-jni PROPERTIES LINK_DEPENDS
         ${CMAKE_CURRENT_SOURCE_DIR}/libfilament-utils-jni.symbols)
@@ -71,4 +78,6 @@ target_link_libraries(filament-utils-jni
         image
         ktxreader
         viewer
+        bluevk
+        android
 )

android/filament-utils-android/build.gradle

@@ -12,6 +12,10 @@ android {
         }
     }
 
+    defaultConfig {
+        minSdkVersion 26
+    }        
+
     packagingOptions {
         // No need to package up the following shared libs, which arise as a side effect of our
         // externalNativeBuild dependencies. When clients pick and choose from project-level gradle

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

@@ -14,12 +14,21 @@
  * limitations under the License.
  */
 
+
+#include <android/hardware_buffer.h>
+#include <android/hardware_buffer_jni.h>
 #include <jni.h>
 
 #include <filament/Engine.h>
 #include <filament/IndirectLight.h>
 #include <filament/Skybox.h>
 
+#include <backend/Platform.h>
+#include <backend/platforms/PlatformEGLAndroid.h>
+#include <backend/platforms/VulkanPlatformAndroid.h>
+
+#include <utils/Log.h>
+
 #include <ktxreader/Ktx1Reader.h>
 
 #include "common/NioUtils.h"
@@ -29,6 +38,8 @@ using namespace filament::math;
 using namespace image;
 using namespace ktxreader;
 
+using namespace filament::backend;
+
 jlong nCreateHDRTexture(JNIEnv* env, jclass,
         jlong nativeEngine, jobject javaBuffer, jint remaining, jint internalFormat);
 
@@ -79,6 +90,37 @@ static jboolean nGetSphericalHarmonics(JNIEnv* env, jclass, jobject javaBuffer,
     return success ? JNI_TRUE : JNI_FALSE;
 }
 
+static jlong nSetExternalImageOnTexture(JNIEnv* env, jclass, jlong nativeEngine, jlong nativeTexture,
+        jobject hardwareBuffer, jboolean srgb) {
+    utils::slog.e <<"--------- jni nSetExternalImageOnTexture" << utils::io::endl;
+    Engine* engine = (Engine*) nativeEngine;
+    Texture* texture = (Texture*) nativeTexture;
+
+    Platform* platform = engine->getPlatform();
+    AHardwareBuffer* nativeBuffer = nullptr;
+    if (__builtin_available(android 26, *)) {
+        nativeBuffer = AHardwareBuffer_fromHardwareBuffer(env, hardwareBuffer);
+    }
+
+    utils::slog.e <<"--------- jni nSetExternalImageOnTexture buf=" << nativeBuffer << utils::io::endl;    
+
+    if (!nativeBuffer) {
+        return 0;
+    }
+
+    if (engine->getBackend() == Backend::OPENGL) {
+        PlatformEGLAndroid* eglPlatform = (PlatformEGLAndroid*) platform;
+        auto ref = eglPlatform->createExternalImage(nativeBuffer, srgb == JNI_TRUE);
+        texture->setExternalImage(*engine, ref);
+    } else if (engine->getBackend() == Backend::VULKAN) {
+        VulkanPlatformAndroid* vulkanPlatform = (VulkanPlatformAndroid*) platform;
+        auto ref = vulkanPlatform->createExternalImage(nativeBuffer, srgb == JNI_TRUE);
+        texture->setExternalImage(*engine, ref);
+    }
+    return 0;    
+}
+
+
 JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void*) {
     JNIEnv* env;
     if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
@@ -108,5 +150,14 @@ JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void*) {
     rc = env->RegisterNatives(hdrloaderClass, hdrMethods, sizeof(hdrMethods) / sizeof(JNINativeMethod));
     if (rc != JNI_OK) return rc;
 
+    jclass loaderClass = env->FindClass("com/google/android/filament/utils/ExternalImage");
+    if (loaderClass == nullptr) return JNI_ERR;
+    static const JNINativeMethod methods[] = {
+        { (char*) "nSetExternalImageOnTexture", (char*) "(JJLandroid/hardware/HardwareBuffer;Z)J",
+            reinterpret_cast<void*>(nSetExternalImageOnTexture) },
+    };
+    rc = env->RegisterNatives(loaderClass, methods, sizeof(methods) / sizeof(JNINativeMethod));
+    if (rc != JNI_OK) return rc;    
+
     return JNI_VERSION_1_6;
 }

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

@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2017 Romain Guy
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.android.filament.utils
+
+import android.hardware.HardwareBuffer
+import com.google.android.filament.Engine
+import com.google.android.filament.Texture
+
+object ExternalImage {
+    fun setOnTexture(
+        engine: Engine,
+        texture: Texture,
+        buffer: HardwareBuffer,
+        srgb: Boolean,
+    ) {
+        val nativeEngine = engine.nativeObject
+        val nativeTexture = texture.nativeObject
+        val l = nSetExternalImageOnTexture(nativeEngine, nativeTexture, buffer, srgb)
+    }
+
+    private external fun nSetExternalImageOnTexture(
+        nativeEngine: Long,
+        nativeTexture: Long,
+        buffer: HardwareBuffer,
+        srgb: Boolean,
+    ): Long
+}

android/samples/sample-external-image/.gitignore

@@ -0,0 +1,12 @@
+*.iml
+.gradle
+/local.properties
+/.idea/workspace.xml
+/.idea/libraries
+/.idea/caches
+/.idea/gradle.xml
+.DS_Store
+/build
+/captures
+/src/main/assets
+.externalNativeBuild

android/samples/sample-external-image/build.gradle

@@ -0,0 +1,55 @@
+plugins {
+    id 'com.android.application'
+    id 'kotlin-android'
+    id 'filament-tools-plugin'
+}
+
+project.ext.isSample = true
+
+kotlin {
+    jvmToolchain(versions.jdk)
+}
+
+filamentTools {
+    materialInputDir = project.layout.projectDirectory.dir("src/main/materials")
+    materialOutputDir = project.layout.projectDirectory.dir("src/main/assets/materials")
+}
+
+clean.doFirst {
+    delete "src/main/assets"
+}
+
+android {
+    namespace 'com.google.android.filament.externalimg'
+
+    compileSdkVersion versions.compileSdk
+    defaultConfig {
+        applicationId "com.google.android.filament.externalimg"
+        minSdkVersion 26
+        targetSdkVersion versions.targetSdk
+    }
+
+    // NOTE: This is a workaround required because the AGP task collectReleaseDependencies
+    //       is not configuration-cache friendly yet; this is only useful for Play publication
+    dependenciesInfo {
+        includeInApk = false
+    }
+
+    // We use the .filamat extension for materials compiled with matc
+    // Telling aapt to not compress them allows to load them efficiently
+    aaptOptions {
+        noCompress 'filamat', 'ktx'
+    }
+
+    compileOptions {
+        sourceCompatibility versions.jdk
+        targetCompatibility versions.jdk
+    }
+}
+
+dependencies {
+    implementation deps.kotlin
+    implementation deps.androidx.core
+    implementation project(':filament-android')
+    implementation project(':filament-utils-android')    
+}

android/samples/sample-external-image/src/main/AndroidManifest.xml

@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<!--
+  Copyright (C) 2019 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.
+ -->
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+  <uses-permission android:name="android.permission.CAMERA" />
+
+  <uses-feature android:name="android.hardware.camera" />
+  <uses-feature android:name="android.hardware.camera.autofocus" />
+
+  <application
+      android:allowBackup="true"
+      android:icon="@mipmap/ic_launcher"
+      android:label="@string/app_name"
+      android:roundIcon="@mipmap/ic_launcher_round"
+      android:supportsRtl="true"
+      android:theme="@style/AppTheme">
+    <activity
+        android:exported="true"
+        android:name=".MainActivity">
+      <intent-filter>
+        <action android:name="android.intent.action.MAIN"/>
+
+        <category android:name="android.intent.category.LAUNCHER"/>
+      </intent-filter>
+    </activity>
+  </application>
+
+</manifest>

android/samples/sample-external-image/src/main/java/com/google/android/filament/externalimg/CameraHelper.kt

@@ -0,0 +1,247 @@
+/*
+ * Copyright (C) 2019 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.externalimg
+
+import android.app.Activity
+import android.content.Context
+import android.content.pm.PackageManager
+import android.graphics.SurfaceTexture
+import android.hardware.camera2.*
+import android.os.Handler
+import android.os.HandlerThread
+import android.util.Log
+import android.util.Size
+import android.view.Surface
+import androidx.core.content.ContextCompat
+
+import android.Manifest
+import android.graphics.ImageFormat
+import android.hardware.HardwareBuffer
+import android.media.ImageReader
+import android.opengl.Matrix
+import android.os.Build
+import android.os.Looper
+import androidx.annotation.RequiresApi
+
+import com.google.android.filament.*
+
+import java.util.concurrent.Semaphore
+import java.util.concurrent.TimeUnit
+
+/**
+ * Toy class that handles all interaction with the Android camera2 API.
+ * Sets the "textureTransform" and "videoTexture" parameters on the given Filament material.
+ */
+class CameraHelper(val activity: Activity, private val filamentEngine: Engine, private val filamentMaterial: MaterialInstance) {
+    private lateinit var cameraId: String
+    private lateinit var captureRequest: CaptureRequest
+
+    private val cameraOpenCloseLock = Semaphore(1)
+    private var backgroundHandler: Handler? = null
+    private var backgroundThread: HandlerThread? = null
+    private var cameraDevice: CameraDevice? = null
+    private var captureSession: CameraCaptureSession? = null
+    private var resolution = Size(640, 480)
+    private var filamentTexture: Texture? = null
+    private var filamentStream: Stream? = null
+    private val imageReader = ImageReader.newInstance(
+            resolution.width,
+            resolution.height,
+            ImageFormat.PRIVATE,
+            kImageReaderMaxImages,
+            HardwareBuffer.USAGE_GPU_SAMPLED_IMAGE)
+
+    @Suppress("deprecation")
+    private val display = if (Build.VERSION.SDK_INT >= 30) {
+        Api30Impl.getDisplay(activity)
+    } else {
+        activity.windowManager.defaultDisplay!!
+    }
+
+    @RequiresApi(30)
+    class Api30Impl {
+        companion object {
+            fun getDisplay(context: Context) = context.display!!
+        }
+    }
+
+    private val cameraCallback = object : CameraDevice.StateCallback() {
+        override fun onOpened(cameraDevice: CameraDevice) {
+            cameraOpenCloseLock.release()
+            this@CameraHelper.cameraDevice = cameraDevice
+            createCaptureSession()
+        }
+        override fun onDisconnected(cameraDevice: CameraDevice) {
+            cameraOpenCloseLock.release()
+            cameraDevice.close()
+            this@CameraHelper.cameraDevice = null
+        }
+        override fun onError(cameraDevice: CameraDevice, error: Int) {
+            onDisconnected(cameraDevice)
+            this@CameraHelper.activity.finish()
+        }
+    }
+
+    /**
+     * Fetches the latest image (if any) from ImageReader and passes its HardwareBuffer to Filament.
+     */
+    fun pushExternalImageToFilament() {
+        val stream = filamentStream
+        if (stream != null) {
+            imageReader.acquireLatestImage()?.also {
+                stream.setAcquiredImage(it.hardwareBuffer, Handler(Looper.getMainLooper())) {
+                    it.close()
+                }
+            }
+        }
+    }
+
+    /**
+     * Finds the front-facing Android camera, requests permission, and sets up a listener that will
+     * start a capture session as soon as the camera is ready.
+     */
+    fun openCamera() {
+        val manager = activity.getSystemService(Context.CAMERA_SERVICE) as CameraManager
+        try {
+            for (cameraId in manager.cameraIdList) {
+                val characteristics = manager.getCameraCharacteristics(cameraId)
+                val cameraDirection = characteristics.get(CameraCharacteristics.LENS_FACING)
+                if (cameraDirection != null && cameraDirection == CameraCharacteristics.LENS_FACING_FRONT) {
+                    continue
+                }
+
+                this.cameraId = cameraId
+                Log.i(kLogTag, "Selected camera $cameraId.")
+
+                val map = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP) ?: continue
+                resolution = map.getOutputSizes(SurfaceTexture::class.java)[0]
+                Log.i(kLogTag, "Highest resolution is $resolution.")
+            }
+        } catch (e: CameraAccessException) {
+            Log.e(kLogTag, e.toString())
+        } catch (e: NullPointerException) {
+            Log.e(kLogTag, "Camera2 API is not supported on this device.")
+        }
+
+        val permission = ContextCompat.checkSelfPermission(this.activity, Manifest.permission.CAMERA)
+        if (permission != PackageManager.PERMISSION_GRANTED) {
+            activity.requestPermissions(arrayOf(Manifest.permission.CAMERA), kRequestCameraPermission)
+            return
+        }
+        if (!cameraOpenCloseLock.tryAcquire(2500, TimeUnit.MILLISECONDS)) {
+            throw RuntimeException("Time out waiting to lock camera opening.")
+        }
+        manager.openCamera(cameraId, cameraCallback, backgroundHandler)
+    }
+
+    fun onResume() {
+        backgroundThread = HandlerThread("CameraBackground").also { it.start() }
+        backgroundHandler = Handler(backgroundThread?.looper!!)
+    }
+
+    fun onPause() {
+        backgroundThread?.quitSafely()
+        try {
+            backgroundThread?.join()
+            backgroundThread = null
+            backgroundHandler = null
+        } catch (e: InterruptedException) {
+            Log.e(kLogTag, e.toString())
+        }
+    }
+
+    fun onRequestPermissionsResult(requestCode: Int, grantResults: IntArray): Boolean {
+        if (requestCode == kRequestCameraPermission) {
+            if (grantResults.size != 1 || grantResults[0] != PackageManager.PERMISSION_GRANTED) {
+                Log.e(kLogTag, "Unable to obtain camera position.")
+            }
+            return true
+        }
+        return false
+    }
+
+    private fun createCaptureSession() {
+        filamentStream?.apply { filamentEngine.destroyStream(this) }
+
+        // [Re]create the Filament Stream object that gets bound to the Texture.
+        filamentStream = Stream.Builder().build(filamentEngine)
+
+        // Create the Filament Texture object if we haven't done so already.
+        if (filamentTexture == null) {
+            filamentTexture = Texture.Builder()
+                    .sampler(Texture.Sampler.SAMPLER_EXTERNAL)
+                    .format(Texture.InternalFormat.RGB8)
+                    .build(filamentEngine)
+        }
+
+        // We are texturing a front-facing square shape so we need to generate a matrix that transforms (u, v, 0, 1)
+        // into a new UV coordinate according to the screen rotation and the aspect ratio of the camera image.
+        val aspectRatio = resolution.width.toFloat() / resolution.height.toFloat()
+        val textureTransform = FloatArray(16)
+        Matrix.setIdentityM(textureTransform, 0)
+        when (display.rotation) {
+            Surface.ROTATION_0 -> {
+                Matrix.translateM(textureTransform, 0, 1.0f, 0.0f, 0.0f)
+                Matrix.rotateM(textureTransform, 0, 90.0f, 0.0f, 0.0f, 1.0f)
+                Matrix.translateM(textureTransform, 0, 1.0f, 0.0f, 0.0f)
+                Matrix.scaleM(textureTransform, 0, -1.0f, 1.0f / aspectRatio, 1.0f)
+            }
+            Surface.ROTATION_90 -> {
+                Matrix.translateM(textureTransform, 0, 1.0f, 1.0f, 0.0f)
+                Matrix.rotateM(textureTransform, 0, 180.0f, 0.0f, 0.0f, 1.0f)
+                Matrix.translateM(textureTransform, 0, 1.0f, 0.0f, 0.0f)
+                Matrix.scaleM(textureTransform, 0, -1.0f / aspectRatio, 1.0f, 1.0f)
+            }
+            Surface.ROTATION_270 -> {
+                Matrix.translateM(textureTransform, 0, 1.0f, 0.0f, 0.0f)
+                Matrix.scaleM(textureTransform, 0, -1.0f / aspectRatio, 1.0f, 1.0f)
+            }
+        }
+
+        // Connect the Stream to the Texture and the Texture to the MaterialInstance.
+        val sampler = TextureSampler(TextureSampler.MinFilter.LINEAR, TextureSampler.MagFilter.LINEAR, TextureSampler.WrapMode.CLAMP_TO_EDGE)
+        filamentTexture!!.setExternalStream(filamentEngine, filamentStream!!)
+        filamentMaterial.setParameter("videoTexture", filamentTexture!!, sampler)
+        filamentMaterial.setParameter("textureTransform", MaterialInstance.FloatElement.MAT4, textureTransform, 0, 1)
+
+        // Start the capture session. You could also use TEMPLATE_PREVIEW here.
+        val captureRequestBuilder = cameraDevice!!.createCaptureRequest(CameraDevice.TEMPLATE_RECORD)
+        captureRequestBuilder.addTarget(imageReader.surface)
+
+        cameraDevice?.createCaptureSession(listOf(imageReader.surface),
+                object : CameraCaptureSession.StateCallback() {
+                    override fun onConfigured(cameraCaptureSession: CameraCaptureSession) {
+                        if (cameraDevice == null) return
+                        captureSession = cameraCaptureSession
+                        captureRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE)
+                        captureRequest = captureRequestBuilder.build()
+                        captureSession!!.setRepeatingRequest(captureRequest, null, backgroundHandler)
+                        Log.i(kLogTag, "Created CaptureRequest.")
+                    }
+                    override fun onConfigureFailed(session: CameraCaptureSession) {
+                        Log.e(kLogTag, "onConfigureFailed")
+                    }
+                }, null)
+    }
+
+    companion object {
+        private const val kLogTag = "CameraHelper"
+        private const val kRequestCameraPermission = 1
+        private const val kImageReaderMaxImages = 7
+    }
+
+}

android/samples/sample-external-image/src/main/java/com/google/android/filament/externalimg/CameraHelper.kt~

@@ -0,0 +1,247 @@
+/*
+ * Copyright (C) 2019 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.externalimg
+
+import android.app.Activity
+import android.content.Context
+import android.content.pm.PackageManager
+import android.graphics.SurfaceTexture
+import android.hardware.camera2.*
+import android.os.Handler
+import android.os.HandlerThread
+import android.util.Log
+import android.util.Size
+import android.view.Surface
+import androidx.core.content.ContextCompat
+
+import android.Manifest
+import android.graphics.ImageFormat
+import android.hardware.HardwareBuffer
+import android.media.ImageReader
+import android.opengl.Matrix
+import android.os.Build
+import android.os.Looper
+import androidx.annotation.RequiresApi
+
+import com.google.android.filament.*
+
+import java.util.concurrent.Semaphore
+import java.util.concurrent.TimeUnit
+
+/**
+ * Toy class that handles all interaction with the Android camera2 API.
+ * Sets the "textureTransform" and "videoTexture" parameters on the given Filament material.
+ */
+class CameraHelper(val activity: Activity, private val filamentEngine: Engine, private val filamentMaterial: MaterialInstance) {
+    private lateinit var cameraId: String
+    private lateinit var captureRequest: CaptureRequest
+
+    private val cameraOpenCloseLock = Semaphore(1)
+    private var backgroundHandler: Handler? = null
+    private var backgroundThread: HandlerThread? = null
+    private var cameraDevice: CameraDevice? = null
+    private var captureSession: CameraCaptureSession? = null
+    private var resolution = Size(640, 480)
+    private var filamentTexture: Texture? = null
+    private var filamentStream: Stream? = null
+    private val imageReader = ImageReader.newInstance(
+            resolution.width,
+            resolution.height,
+            ImageFormat.PRIVATE,
+            kImageReaderMaxImages,
+            HardwareBuffer.USAGE_GPU_SAMPLED_IMAGE)
+
+    @Suppress("deprecation")
+    private val display = if (Build.VERSION.SDK_INT >= 30) {
+        Api30Impl.getDisplay(activity)
+    } else {
+        activity.windowManager.defaultDisplay!!
+    }
+
+    @RequiresApi(30)
+    class Api30Impl {
+        companion object {
+            fun getDisplay(context: Context) = context.display!!
+        }
+    }
+
+    private val cameraCallback = object : CameraDevice.StateCallback() {
+        override fun onOpened(cameraDevice: CameraDevice) {
+            cameraOpenCloseLock.release()
+            this@CameraHelper.cameraDevice = cameraDevice
+            createCaptureSession()
+        }
+        override fun onDisconnected(cameraDevice: CameraDevice) {
+            cameraOpenCloseLock.release()
+            cameraDevice.close()
+            this@CameraHelper.cameraDevice = null
+        }
+        override fun onError(cameraDevice: CameraDevice, error: Int) {
+            onDisconnected(cameraDevice)
+            this@CameraHelper.activity.finish()
+        }
+    }
+
+    /**
+     * Fetches the latest image (if any) from ImageReader and passes its HardwareBuffer to Filament.
+     */
+    fun pushExternalImageToFilament() {
+        val stream = filamentStream
+        if (stream != null) {
+            imageReader.acquireLatestImage()?.also {
+                stream.setAcquiredImage(it.hardwareBuffer, Handler(Looper.getMainLooper())) {
+                    it.close()
+                }
+            }
+        }
+    }
+
+    /**
+     * Finds the front-facing Android camera, requests permission, and sets up a listener that will
+     * start a capture session as soon as the camera is ready.
+     */
+    fun openCamera() {
+        val manager = activity.getSystemService(Context.CAMERA_SERVICE) as CameraManager
+        try {
+            for (cameraId in manager.cameraIdList) {
+                val characteristics = manager.getCameraCharacteristics(cameraId)
+                val cameraDirection = characteristics.get(CameraCharacteristics.LENS_FACING)
+                if (cameraDirection != null && cameraDirection == CameraCharacteristics.LENS_FACING_FRONT) {
+                    continue
+                }
+
+                this.cameraId = cameraId
+                Log.i(kLogTag, "Selected camera $cameraId.")
+
+                val map = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP) ?: continue
+                resolution = map.getOutputSizes(SurfaceTexture::class.java)[0]
+                Log.i(kLogTag, "Highest resolution is $resolution.")
+            }
+        } catch (e: CameraAccessException) {
+            Log.e(kLogTag, e.toString())
+        } catch (e: NullPointerException) {
+            Log.e(kLogTag, "Camera2 API is not supported on this device.")
+        }
+
+        val permission = ContextCompat.checkSelfPermission(this.activity, Manifest.permission.CAMERA)
+        if (permission != PackageManager.PERMISSION_GRANTED) {
+            activity.requestPermissions(arrayOf(Manifest.permission.CAMERA), kRequestCameraPermission)
+            return
+        }
+        if (!cameraOpenCloseLock.tryAcquire(2500, TimeUnit.MILLISECONDS)) {
+            throw RuntimeException("Time out waiting to lock camera opening.")
+        }
+        manager.openCamera(cameraId, cameraCallback, backgroundHandler)
+    }
+
+    fun onResume() {
+        backgroundThread = HandlerThread("CameraBackground").also { it.start() }
+        backgroundHandler = Handler(backgroundThread?.looper!!)
+    }
+
+    fun onPause() {
+        backgroundThread?.quitSafely()
+        try {
+            backgroundThread?.join()
+            backgroundThread = null
+            backgroundHandler = null
+        } catch (e: InterruptedException) {
+            Log.e(kLogTag, e.toString())
+        }
+    }
+
+    fun onRequestPermissionsResult(requestCode: Int, grantResults: IntArray): Boolean {
+        if (requestCode == kRequestCameraPermission) {
+            if (grantResults.size != 1 || grantResults[0] != PackageManager.PERMISSION_GRANTED) {
+                Log.e(kLogTag, "Unable to obtain camera position.")
+            }
+            return true
+        }
+        return false
+    }
+
+    private fun createCaptureSession() {
+        filamentStream?.apply { filamentEngine.destroyStream(this) }
+
+        // [Re]create the Filament Stream object that gets bound to the Texture.
+        filamentStream = Stream.Builder().build(filamentEngine)
+
+        // Create the Filament Texture object if we haven't done so already.
+        if (filamentTexture == null) {
+            filamentTexture = Texture.Builder()
+                    .sampler(Texture.Sampler.SAMPLER_EXTERNAL)
+                    .format(Texture.InternalFormat.RGB8)
+                    .build(filamentEngine)
+        }
+
+        // We are texturing a front-facing square shape so we need to generate a matrix that transforms (u, v, 0, 1)
+        // into a new UV coordinate according to the screen rotation and the aspect ratio of the camera image.
+        val aspectRatio = resolution.width.toFloat() / resolution.height.toFloat()
+        val textureTransform = FloatArray(16)
+        Matrix.setIdentityM(textureTransform, 0)
+        when (display.rotation) {
+            Surface.ROTATION_0 -> {
+                Matrix.translateM(textureTransform, 0, 1.0f, 0.0f, 0.0f)
+                Matrix.rotateM(textureTransform, 0, 90.0f, 0.0f, 0.0f, 1.0f)
+                Matrix.translateM(textureTransform, 0, 1.0f, 0.0f, 0.0f)
+                Matrix.scaleM(textureTransform, 0, -1.0f, 1.0f / aspectRatio, 1.0f)
+            }
+            Surface.ROTATION_90 -> {
+                Matrix.translateM(textureTransform, 0, 1.0f, 1.0f, 0.0f)
+                Matrix.rotateM(textureTransform, 0, 180.0f, 0.0f, 0.0f, 1.0f)
+                Matrix.translateM(textureTransform, 0, 1.0f, 0.0f, 0.0f)
+                Matrix.scaleM(textureTransform, 0, -1.0f / aspectRatio, 1.0f, 1.0f)
+            }
+            Surface.ROTATION_270 -> {
+                Matrix.translateM(textureTransform, 0, 1.0f, 0.0f, 0.0f)
+                Matrix.scaleM(textureTransform, 0, -1.0f / aspectRatio, 1.0f, 1.0f)
+            }
+        }
+
+        // Connect the Stream to the Texture and the Texture to the MaterialInstance.
+        val sampler = TextureSampler(TextureSampler.MinFilter.LINEAR, TextureSampler.MagFilter.LINEAR, TextureSampler.WrapMode.CLAMP_TO_EDGE)
+        filamentTexture!!.setExternalStream(filamentEngine, filamentStream!!)
+        filamentMaterial.setParameter("videoTexture", filamentTexture!!, sampler)
+        filamentMaterial.setParameter("textureTransform", MaterialInstance.FloatElement.MAT4, textureTransform, 0, 1)
+
+        // Start the capture session. You could also use TEMPLATE_PREVIEW here.
+        val captureRequestBuilder = cameraDevice!!.createCaptureRequest(CameraDevice.TEMPLATE_RECORD)
+        captureRequestBuilder.addTarget(imageReader.surface)
+
+        cameraDevice?.createCaptureSession(listOf(imageReader.surface),
+                object : CameraCaptureSession.StateCallback() {
+                    override fun onConfigured(cameraCaptureSession: CameraCaptureSession) {
+                        if (cameraDevice == null) return
+                        captureSession = cameraCaptureSession
+                        captureRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE)
+                        captureRequest = captureRequestBuilder.build()
+                        captureSession!!.setRepeatingRequest(captureRequest, null, backgroundHandler)
+                        Log.i(kLogTag, "Created CaptureRequest.")
+                    }
+                    override fun onConfigureFailed(session: CameraCaptureSession) {
+                        Log.e(kLogTag, "onConfigureFailed")
+                    }
+                }, null)
+    }
+
+    companion object {
+        private const val kLogTag = "CameraHelper"
+        private const val kRequestCameraPermission = 1
+        private const val kImageReaderMaxImages = 7
+    }
+
+}

android/samples/sample-external-image/src/main/java/com/google/android/filament/externalimg/ExternalImageHelper.kt

@@ -0,0 +1,193 @@
+import android.graphics.*
+import android.hardware.HardwareBuffer
+import android.media.Image
+import android.media.ImageReader
+import android.os.Build
+import android.os.Handler
+import android.os.HandlerThread
+import android.util.Log
+import android.view.Surface
+import androidx.annotation.RequiresApi
+import java.util.concurrent.CompletableFuture
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.TimeoutException
+
+@RequiresApi(Build.VERSION_CODES.O)
+object CanvasToHardwareBufferUtil {
+    private const val TAG = "CanvasToHardwareBufferKt"
+    private const val IMAGE_READER_TIMEOUT_MS = 3000L // Timeout for waiting buffer
+
+    fun drawToHardwareBuffer(
+        width: Int,
+        height: Int,
+    ): HardwareBuffer? {
+        if (width <= 0 || height <= 0) {
+            Log.e(TAG, "Invalid dimensions: width=$width, height=$height")
+            return null
+        }
+
+        var handlerThread: HandlerThread? = null
+        var imageReader: ImageReader? = null
+        var surface: Surface? = null // Keep track for logging/debugging if needed
+        // Use var as it's assigned within the try block after future completion
+        var receivedHardwareBuffer: HardwareBuffer? = null
+
+        try {
+            // 1. Setup HandlerThread for ImageReader callbacks
+            handlerThread = HandlerThread("ImageReaderThreadKt").apply { start() }
+            val imageReaderHandler = Handler(handlerThread.looper)
+
+            // 2. Use CompletableFuture to wait for the buffer from the listener
+            val bufferFuture = CompletableFuture<HardwareBuffer>()
+
+            // 3. Create ImageReader
+            val usageFlags =
+                HardwareBuffer.USAGE_GPU_SAMPLED_IMAGE or
+                    HardwareBuffer.USAGE_GPU_COLOR_OUTPUT or
+                    HardwareBuffer.USAGE_CPU_READ_RARELY // Adjust as needed
+
+            imageReader =
+                ImageReader.newInstance(width, height, PixelFormat.RGBA_8888, 1, usageFlags)
+
+            // 4. Set Listener to capture the buffer
+            imageReader.setOnImageAvailableListener({ reader ->
+                var image: Image? = null
+                var hardwareBuffer: HardwareBuffer? = null
+                try {
+                    // Use `use` block for automatic image.close()
+                    image = reader.acquireLatestImage()
+                    if (image == null) {
+                        Log.w(TAG, "ImageReader listener fired but no image available.")
+                        // Complete exceptionally if buffer wasn't already completed.
+                        bufferFuture.completeExceptionally(
+                            RuntimeException("ImageReader listener fired but no image available"),
+                        )
+                        return@setOnImageAvailableListener
+                    }
+
+                    hardwareBuffer = image.hardwareBuffer
+                    if (hardwareBuffer != null) {
+                        // IMPORTANT: Don't close the HardwareBuffer here!
+                        // Transfer ownership via the CompletableFuture.
+                        if (!bufferFuture.isDone) { // Avoid completing more than once
+                            bufferFuture.complete(hardwareBuffer)
+                        } else {
+                            // Future was already completed (maybe exceptionally), close this buffer
+                            Log.w(TAG, "Future already done, closing redundant HardwareBuffer")
+                            hardwareBuffer.close()
+                        }
+                    } else {
+                        Log.e(TAG, "Failed to get HardwareBuffer from Image.")
+                        if (!bufferFuture.isDone) {
+                            bufferFuture.completeExceptionally(
+                                RuntimeException("Failed to get HardwareBuffer from Image"),
+                            )
+                        }
+                    }
+                } catch (e: Exception) {
+                    Log.e(TAG, "Error in ImageReader listener", e)
+                    if (!bufferFuture.isDone) {
+                        bufferFuture.completeExceptionally(e) // Propagate error
+                    }
+                    // If we got the buffer but failed elsewhere, ensure it's closed
+                    hardwareBuffer?.takeUnless { it.isClosed }?.close()
+                } finally {
+                    // image?.close() // Handled by acquiring reader itself or image.use{} if used
+                    image?.close() // Close image if not using `use` or if error before `use` finishes
+                }
+            }, imageReaderHandler)
+
+            // 5. Get the Surface to draw onto
+            surface =
+                imageReader.surface
+                    ?: throw RuntimeException("Failed to get Surface from ImageReader")
+
+            // 6. Lock Canvas and Draw
+            val canvas: Canvas? = surface.lockHardwareCanvas() // Use hardware accelerated canvas
+            if (canvas != null) {
+                try {
+                    // --- Your Drawing Code Here ---
+                    val paint =
+                        Paint().apply {
+                            isAntiAlias = true // Good practice
+                        }
+
+                    // Blue background
+                    paint.color = Color.BLUE
+                    canvas.drawRect(0f, 0f, width.toFloat(), height.toFloat(), paint)
+
+                    // White text
+                    paint.color = Color.WHITE
+                    paint.textSize = 40f
+                    paint.textAlign = Paint.Align.CENTER
+                    canvas.drawText(
+                        "Hello HardwareBuffer! (Kotlin)",
+                        width / 2f,
+                        height / 2f,
+                        paint,
+                    )
+                    // --- End Drawing Code ---
+                } finally {
+                    // 7. Unlock Canvas and Post
+                    surface.unlockCanvasAndPost(canvas)
+                }
+            } else {
+                throw RuntimeException("Failed to lock Hardware Canvas")
+            }
+
+            // 8. Wait for the listener to provide the HardwareBuffer
+            try {
+                // Wait for the buffer; this blocks the current thread.
+                receivedHardwareBuffer =
+                    bufferFuture.get(IMAGE_READER_TIMEOUT_MS, TimeUnit.MILLISECONDS)
+                // Ownership of receivedHardwareBuffer is now transferred to the caller
+            } catch (timeout: TimeoutException) {
+                Log.e(TAG, "Timeout waiting for HardwareBuffer from ImageReader listener")
+                bufferFuture.cancel(true) // Attempt to cancel listener processing
+                throw timeout // Re-throw
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to draw to HardwareBuffer", e)
+            // Ensure buffer is closed if acquired but an error occurred before returning it
+            receivedHardwareBuffer?.takeUnless { it.isClosed }?.close()
+            return null // Indicate failure
+        } finally {
+            // 9. Cleanup
+            try {
+                imageReader?.close() // Also releases the Surface implicitly
+            } catch (e: Exception) {
+                Log.e(TAG, "Error closing ImageReader", e)
+            }
+            try {
+                handlerThread?.quitSafely()
+            } catch (e: Exception) {
+                Log.e(TAG, "Error quitting HandlerThread", e)
+            }
+            // Note: Do NOT close receivedHardwareBuffer here if returning successfully.
+            // The caller is responsible for closing the returned buffer.
+        }
+
+        // Return the buffer; caller MUST close it.
+        return receivedHardwareBuffer
+    }
+
+    // --- Example Usage (must be called from appropriate context/thread, like a coroutine) ---
+    /*
+    @RequiresApi(Build.VERSION_CODES.O)
+    suspend fun exampleUsage() = withContext(Dispatchers.IO) { // Run blocking code off main thread
+        val myBuffer: HardwareBuffer? = CanvasToHardwareBufferUtil.drawToHardwareBuffer(640, 480)
+
+        // Use the 'use' extension function for automatic closing
+        myBuffer?.use { buffer ->
+            // ... Use the buffer (e.g., create an EGLImage, pass to Vulkan, etc.) ...
+            Log.d(TAG, "Successfully created HardwareBuffer: $buffer. Now using it...")
+            // buffer.close() // 'use' handles this automatically
+
+        } ?: run {
+             Log.e(TAG, "Failed to create HardwareBuffer.")
+        }
+
+         Log.d(TAG,"HardwareBuffer processing finished (buffer closed if obtained).")
+    }
+     */
+}

android/samples/sample-external-image/src/main/java/com/google/android/filament/externalimg/ExternalImageHelper.kt~

@@ -0,0 +1,180 @@
+import android.graphics.*
+import android.hardware.HardwareBuffer
+import android.media.Image
+import android.media.ImageReader
+import android.os.Build
+import android.os.Handler
+import android.os.HandlerThread
+import android.util.Log
+import android.view.Surface
+import androidx.annotation.RequiresApi
+import java.util.concurrent.CompletableFuture
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.TimeoutException
+
+@RequiresApi(Build.VERSION_CODES.O)
+object CanvasToHardwareBufferUtil {
+
+    private const val TAG = "CanvasToHardwareBufferKt"
+    private const val IMAGE_READER_TIMEOUT_MS = 3000L // Timeout for waiting buffer
+
+    fun drawToHardwareBuffer(width: Int, height: Int): HardwareBuffer? {
+        if (width <= 0 || height <= 0) {
+            Log.e(TAG, "Invalid dimensions: width=$width, height=$height")
+            return null
+        }
+
+        var handlerThread: HandlerThread? = null
+        var imageReader: ImageReader? = null
+        var surface: Surface? = null // Keep track for logging/debugging if needed
+        // Use var as it's assigned within the try block after future completion
+        var receivedHardwareBuffer: HardwareBuffer? = null
+
+        try {
+            // 1. Setup HandlerThread for ImageReader callbacks
+            handlerThread = HandlerThread("ImageReaderThreadKt").apply { start() }
+            val imageReaderHandler = Handler(handlerThread.looper)
+
+            // 2. Use CompletableFuture to wait for the buffer from the listener
+            val bufferFuture = CompletableFuture<HardwareBuffer>()
+
+            // 3. Create ImageReader
+            val usageFlags = HardwareBuffer.USAGE_GPU_SAMPLED_IMAGE or
+                    HardwareBuffer.USAGE_GPU_COLOR_OUTPUT or
+                    HardwareBuffer.USAGE_CPU_READ_RARELY // Adjust as needed
+
+            imageReader = ImageReader.newInstance(width, height, PixelFormat.RGBA_8888, 1, usageFlags)
+
+            // 4. Set Listener to capture the buffer
+            imageReader.setOnImageAvailableListener({ reader ->
+                var image: Image? = null
+                var hardwareBuffer: HardwareBuffer? = null
+                try {
+                    // Use `use` block for automatic image.close()
+                    image = reader.acquireLatestImage()
+                    if (image == null) {
+                        Log.w(TAG, "ImageReader listener fired but no image available.")
+                        // Complete exceptionally if buffer wasn't already completed.
+                        bufferFuture.completeExceptionally(RuntimeException("ImageReader listener fired but no image available"))
+                        return@setOnImageAvailableListener
+                    }
+
+                    hardwareBuffer = image.hardwareBuffer
+                    if (hardwareBuffer != null) {
+                        // IMPORTANT: Don't close the HardwareBuffer here!
+                        // Transfer ownership via the CompletableFuture.
+                        if (!bufferFuture.isDone) { // Avoid completing more than once
+                           bufferFuture.complete(hardwareBuffer)
+                        } else {
+                            // Future was already completed (maybe exceptionally), close this buffer
+                            Log.w(TAG, "Future already done, closing redundant HardwareBuffer")
+                            hardwareBuffer.close()
+                        }
+                    } else {
+                        Log.e(TAG, "Failed to get HardwareBuffer from Image.")
+                        if (!bufferFuture.isDone) {
+                            bufferFuture.completeExceptionally(RuntimeException("Failed to get HardwareBuffer from Image"))
+                        }
+                    }
+                } catch (e: Exception) {
+                    Log.e(TAG, "Error in ImageReader listener", e)
+                    if (!bufferFuture.isDone) {
+                        bufferFuture.completeExceptionally(e) // Propagate error
+                    }
+                    // If we got the buffer but failed elsewhere, ensure it's closed
+                    hardwareBuffer?.takeUnless { it.isClosed }?.close()
+                } finally {
+                    // image?.close() // Handled by acquiring reader itself or image.use{} if used
+                     image?.close() // Close image if not using `use` or if error before `use` finishes
+                }
+            }, imageReaderHandler)
+
+            // 5. Get the Surface to draw onto
+            surface = imageReader.surface ?: throw RuntimeException("Failed to get Surface from ImageReader")
+
+            // 6. Lock Canvas and Draw
+            val canvas: Canvas? = surface.lockHardwareCanvas() // Use hardware accelerated canvas
+            if (canvas != null) {
+                try {
+                    // --- Your Drawing Code Here ---
+                    val paint = Paint().apply {
+                        isAntiAlias = true // Good practice
+                    }
+
+                    // Blue background
+                    paint.color = Color.BLUE
+                    canvas.drawRect(0f, 0f, width.toFloat(), height.toFloat(), paint)
+
+                    // White text
+                    paint.color = Color.WHITE
+                    paint.textSize = 40f
+                    paint.textAlign = Paint.Align.CENTER
+                    canvas.drawText("Hello HardwareBuffer! (Kotlin)", width / 2f, height / 2f, paint)
+                    // --- End Drawing Code ---
+
+                } finally {
+                    // 7. Unlock Canvas and Post
+                    surface.unlockCanvasAndPost(canvas)
+                }
+            } else {
+                throw RuntimeException("Failed to lock Hardware Canvas")
+            }
+
+            // 8. Wait for the listener to provide the HardwareBuffer
+            try {
+                 // Wait for the buffer; this blocks the current thread.
+                receivedHardwareBuffer = bufferFuture.get(IMAGE_READER_TIMEOUT_MS, TimeUnit.MILLISECONDS)
+                 // Ownership of receivedHardwareBuffer is now transferred to the caller
+            } catch(timeout: TimeoutException) {
+                 Log.e(TAG, "Timeout waiting for HardwareBuffer from ImageReader listener")
+                 bufferFuture.cancel(true) // Attempt to cancel listener processing
+                 throw timeout // Re-throw
+            }
+
+
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to draw to HardwareBuffer", e)
+            // Ensure buffer is closed if acquired but an error occurred before returning it
+            receivedHardwareBuffer?.takeUnless { it.isClosed }?.close()
+            return null // Indicate failure
+
+        } finally {
+            // 9. Cleanup
+            try {
+                 imageReader?.close() // Also releases the Surface implicitly
+            } catch (e: Exception) {
+                 Log.e(TAG, "Error closing ImageReader", e)
+            }
+            try {
+                 handlerThread?.quitSafely()
+            } catch (e: Exception) {
+                 Log.e(TAG, "Error quitting HandlerThread", e)
+            }
+            // Note: Do NOT close receivedHardwareBuffer here if returning successfully.
+            // The caller is responsible for closing the returned buffer.
+        }
+
+        // Return the buffer; caller MUST close it.
+        return receivedHardwareBuffer
+    }
+
+    // --- Example Usage (must be called from appropriate context/thread, like a coroutine) ---
+    /*
+    @RequiresApi(Build.VERSION_CODES.O)
+    suspend fun exampleUsage() = withContext(Dispatchers.IO) { // Run blocking code off main thread
+        val myBuffer: HardwareBuffer? = CanvasToHardwareBufferUtil.drawToHardwareBuffer(640, 480)
+
+        // Use the 'use' extension function for automatic closing
+        myBuffer?.use { buffer ->
+            // ... Use the buffer (e.g., create an EGLImage, pass to Vulkan, etc.) ...
+            Log.d(TAG, "Successfully created HardwareBuffer: $buffer. Now using it...")
+            // buffer.close() // 'use' handles this automatically
+
+        } ?: run {
+             Log.e(TAG, "Failed to create HardwareBuffer.")
+        }
+
+         Log.d(TAG,"HardwareBuffer processing finished (buffer closed if obtained).")
+    }
+    */
+}

android/samples/sample-external-image/src/main/java/com/google/android/filament/externalimg/MainActivity.kt

@@ -0,0 +1,469 @@
+/*
+ * Copyright (C) 2019 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.externalimg
+
+import android.animation.ValueAnimator
+import android.app.Activity
+import android.hardware.HardwareBuffer
+import android.opengl.Matrix
+import android.os.Bundle
+import android.view.Choreographer
+import android.view.Surface
+import android.view.SurfaceView
+import android.view.animation.LinearInterpolator
+import androidx.core.app.ActivityCompat
+
+import com.google.android.filament.*
+import com.google.android.filament.RenderableManager.*
+import com.google.android.filament.VertexBuffer.*
+import com.google.android.filament.android.DisplayHelper
+import com.google.android.filament.android.FilamentHelper
+import com.google.android.filament.android.UiHelper
+import com.google.android.filament.utils.ExternalImage
+import com.google.android.filament.utils.Utils
+
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+import java.nio.channels.Channels
+
+import kotlin.math.*
+
+import android.util.Log
+
+class MainActivity : Activity(), ActivityCompat.OnRequestPermissionsResultCallback {
+    companion object {
+        init {
+            Filament.init()
+        }
+    }
+
+    private var TAG = "filament.externalimg"
+
+    private lateinit var surfaceView: SurfaceView
+    private lateinit var uiHelper: UiHelper
+    private lateinit var displayHelper: DisplayHelper
+    private lateinit var choreographer: Choreographer
+
+    private lateinit var engine: Engine
+    private lateinit var renderer: Renderer
+    private lateinit var scene: Scene
+    private lateinit var view: View
+
+    // This is the Filament camera, not the phone camera. :)
+    private lateinit var camera: Camera
+
+    private var filamentTexture: Texture? = null
+
+    // Other Filament objects:
+    private lateinit var material: Material
+    private lateinit var materialInstance: MaterialInstance
+    private lateinit var vertexBuffer: VertexBuffer
+    private lateinit var indexBuffer: IndexBuffer
+
+    // Filament entity representing a renderable object
+    @Entity private var renderable = 0
+    @Entity private var light = 0
+
+    private var myCount : Int = 0
+
+    // A swap chain is Filament's representation of a surface
+    private var swapChain: SwapChain? = null
+
+    // Performs the rendering and schedules new frames
+    private val frameScheduler = FrameCallback()
+
+    private val animator = ValueAnimator.ofFloat(0.0f, 50.0f)
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        Utils.init()
+
+        surfaceView = SurfaceView(this)
+        setContentView(surfaceView)
+
+        choreographer = Choreographer.getInstance()
+
+        displayHelper = DisplayHelper(this)
+
+        setupSurfaceView()
+        setupFilament()
+        setupView()
+        setupScene()
+
+//        ExternalImage.setOnTexture(engine,, texture, buffer, srgb)
+
+//        cameraHelper = CameraHelper(this, engine, materialInstance)
+//        cameraHelper.openCamera()
+    }
+
+    private fun setupSurfaceView() {
+        uiHelper = UiHelper(UiHelper.ContextErrorPolicy.DONT_CHECK)
+        uiHelper.renderCallback = SurfaceCallback()
+        uiHelper.attachTo(surfaceView)
+    }
+
+    private fun setupFilament() {
+        engine = Engine.create()
+        renderer = engine.createRenderer()
+        scene = engine.createScene()
+        view = engine.createView()
+        camera = engine.createCamera(engine.entityManager.create())
+
+    }
+
+    private fun setupView() {
+        scene.skybox = Skybox.Builder().color(0.035f, 0.035f, 0.035f, 1.0f).build(engine)
+        view.camera = camera
+        view.scene = scene
+    }
+
+    private fun setupScene() {
+        loadMaterial()
+        setupMaterial()
+        createMesh()
+
+        // To create a renderable we first create a generic entity
+        renderable = EntityManager.get().create()
+
+        // We then create a renderable component on that entity
+        // A renderable is made of several primitives; in this case we declare only 1
+        // If we wanted each face of the cube to have a different material, we could
+        // declare 6 primitives (1 per face) and give each of them a different material
+        // instance, setup with different parameters
+        RenderableManager.Builder(1)
+                // Overall bounding box of the renderable
+                .boundingBox(Box(0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f))
+                // Sets the mesh data of the first primitive, 6 faces of 6 indices each
+                .geometry(0, PrimitiveType.TRIANGLES, vertexBuffer, indexBuffer, 0, 6 * 6)
+                // Sets the material of the first primitive
+                .material(0, materialInstance)
+                .build(engine, renderable)
+
+        // Add the entity to the scene to render it
+        scene.addEntity(renderable)
+
+        // We now need a light, let's create a directional light
+        light = EntityManager.get().create()
+
+        // Create a color from a temperature (5,500K)
+        val (r, g, b) = Colors.cct(5_500.0f)
+        LightManager.Builder(LightManager.Type.DIRECTIONAL)
+                .color(r, g, b)
+                // Intensity of the sun in lux on a clear day
+                .intensity(110_000.0f)
+                // The direction is normalized on our behalf
+                .direction(0.0f, -0.5f, -1.0f)
+                .castShadows(true)
+                .build(engine, light)
+
+        // Add the entity to the scene to light it
+        scene.addEntity(light)
+
+        // Set the exposure on the camera, this exposure follows the sunny f/16 rule
+        // Since we've defined a light that has the same intensity as the sun, it
+        // guarantees a proper exposure
+        camera.setExposure(16.0f, 1.0f / 125.0f, 100.0f)
+
+        // Move the camera back to see the object
+        camera.lookAt(0.0, 0.0, 6.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0)
+
+        startAnimation()
+    }
+
+    private fun loadMaterial() {
+        readUncompressedAsset("materials/lit.filamat").let {
+            material = Material.Builder().payload(it, it.remaining()).build(engine)
+        }
+    }
+
+    private fun setupMaterial() {
+        materialInstance = material.createInstance()
+        materialInstance.setParameter("baseColor", Colors.RgbType.SRGB, 1.0f, 0.85f, 0.57f)
+        materialInstance.setParameter("roughness", 0.3f)
+
+        val textureTransform = FloatArray(16)
+        Matrix.setIdentityM(textureTransform, 0)
+
+        filamentTexture = Texture.Builder()
+            .sampler(Texture.Sampler.SAMPLER_EXTERNAL)
+            .width(400)
+            .height(400)        
+            .format(Texture.InternalFormat.RGBA8)
+            .build(engine)
+
+        val sampler = TextureSampler(TextureSampler.MinFilter.LINEAR, TextureSampler.MagFilter.LINEAR, TextureSampler.WrapMode.CLAMP_TO_EDGE)
+        materialInstance.setParameter("videoTexture", filamentTexture!!, sampler)
+        materialInstance.setParameter("textureTransform", MaterialInstance.FloatElement.MAT4, textureTransform, 0, 1)
+    }
+
+    private fun createMesh() {
+        val floatSize = 4
+        val shortSize = 2
+        // A vertex is a position + a tangent frame:
+        // 3 floats for XYZ position, 4 floats for normal+tangents (quaternion)
+        val vertexSize = 3 * floatSize + 4 * floatSize
+
+        // Define a vertex and a function to put a vertex in a ByteBuffer
+        @Suppress("ArrayInDataClass")
+        data class Vertex(val x: Float, val y: Float, val z: Float, val tangents: FloatArray)
+        fun ByteBuffer.put(v: Vertex): ByteBuffer {
+            putFloat(v.x)
+            putFloat(v.y)
+            putFloat(v.z)
+            v.tangents.forEach { putFloat(it) }
+            return this
+        }
+
+        // 6 faces, 4 vertices per face
+        val vertexCount = 6 * 4
+
+        // Create tangent frames, one per face
+        val tfPX = FloatArray(4)
+        val tfNX = FloatArray(4)
+        val tfPY = FloatArray(4)
+        val tfNY = FloatArray(4)
+        val tfPZ = FloatArray(4)
+        val tfNZ = FloatArray(4)
+
+        MathUtils.packTangentFrame( 0.0f,  1.0f, 0.0f, 0.0f, 0.0f, -1.0f,  1.0f,  0.0f,  0.0f, tfPX)
+        MathUtils.packTangentFrame( 0.0f,  1.0f, 0.0f, 0.0f, 0.0f, -1.0f, -1.0f,  0.0f,  0.0f, tfNX)
+        MathUtils.packTangentFrame(-1.0f,  0.0f, 0.0f, 0.0f, 0.0f, -1.0f,  0.0f,  1.0f,  0.0f, tfPY)
+        MathUtils.packTangentFrame(-1.0f,  0.0f, 0.0f, 0.0f, 0.0f,  1.0f,  0.0f, -1.0f,  0.0f, tfNY)
+        MathUtils.packTangentFrame( 0.0f,  1.0f, 0.0f, 1.0f, 0.0f,  0.0f,  0.0f,  0.0f,  1.0f, tfPZ)
+        MathUtils.packTangentFrame( 0.0f, -1.0f, 0.0f, 1.0f, 0.0f,  0.0f,  0.0f,  0.0f, -1.0f, tfNZ)
+
+        val vertexData = ByteBuffer.allocate(vertexCount * vertexSize)
+                // It is important to respect the native byte order
+                .order(ByteOrder.nativeOrder())
+                // Face -Z
+                .put(Vertex(-1.5f, -1.5f, -1.0f, tfNZ))
+                .put(Vertex(-1.5f,  1.5f, -1.0f, tfNZ))
+                .put(Vertex( 1.5f,  1.5f, -1.0f, tfNZ))
+                .put(Vertex( 1.5f, -1.5f, -1.0f, tfNZ))
+                // Face +X
+                .put(Vertex( 1.5f, -1.5f, -1.0f, tfPX))
+                .put(Vertex( 1.5f,  1.5f, -1.0f, tfPX))
+                .put(Vertex( 1.0f,  1.0f,  1.0f, tfPX))
+                .put(Vertex( 1.0f, -1.0f,  1.0f, tfPX))
+                // Face +Z
+                .put(Vertex(-1.0f, -1.0f,  1.0f, tfPZ))
+                .put(Vertex( 1.0f, -1.0f,  1.0f, tfPZ))
+                .put(Vertex( 1.0f,  1.0f,  1.0f, tfPZ))
+                .put(Vertex(-1.0f,  1.0f,  1.0f, tfPZ))
+                // Face -X
+                .put(Vertex(-1.0f, -1.0f,  1.0f, tfNX))
+                .put(Vertex(-1.0f,  1.0f,  1.0f, tfNX))
+                .put(Vertex(-1.5f,  1.5f, -1.0f, tfNX))
+                .put(Vertex(-1.5f, -1.5f, -1.0f, tfNX))
+                // Face -Y
+                .put(Vertex(-1.0f, -1.0f,  1.0f, tfNY))
+                .put(Vertex(-1.5f, -1.5f, -1.0f, tfNY))
+                .put(Vertex( 1.5f, -1.5f, -1.0f, tfNY))
+                .put(Vertex( 1.0f, -1.0f,  1.0f, tfNY))
+                // Face +Y
+                .put(Vertex(-1.5f,  1.5f, -1.0f, tfPY))
+                .put(Vertex(-1.0f,  1.0f,  1.0f, tfPY))
+                .put(Vertex( 1.0f,  1.0f,  1.0f, tfPY))
+                .put(Vertex( 1.5f,  1.5f, -1.0f, tfPY))
+                // Make sure the cursor is pointing in the right place in the byte buffer
+                .flip()
+
+        // Declare the layout of our mesh
+        vertexBuffer = VertexBuffer.Builder()
+                .bufferCount(1)
+                .vertexCount(vertexCount)
+                // Because we interleave position and color data we must specify offset and stride
+                // We could use de-interleaved data by declaring two buffers and giving each
+                // attribute a different buffer index
+                .attribute(VertexAttribute.POSITION, 0, AttributeType.FLOAT3, 0,             vertexSize)
+                .attribute(VertexAttribute.TANGENTS, 0, AttributeType.FLOAT4, 3 * floatSize, vertexSize)
+                .build(engine)
+
+        // Feed the vertex data to the mesh
+        // We only set 1 buffer because the data is interleaved
+        vertexBuffer.setBufferAt(engine, 0, vertexData)
+
+        // Create the indices
+        val indexData = ByteBuffer.allocate(6 * 2 * 3 * shortSize)
+                .order(ByteOrder.nativeOrder())
+        repeat(6) {
+            val i = (it * 4).toShort()
+            indexData
+                    .putShort(i).putShort((i + 1).toShort()).putShort((i + 2).toShort())
+                    .putShort(i).putShort((i + 2).toShort()).putShort((i + 3).toShort())
+        }
+        indexData.flip()
+
+        // 6 faces, 2 triangles per face,
+        indexBuffer = IndexBuffer.Builder()
+                .indexCount(vertexCount * 2)
+                .bufferType(IndexBuffer.Builder.IndexType.USHORT)
+                .build(engine)
+        indexBuffer.setBuffer(engine, indexData)
+    }
+
+    private fun startAnimation() {
+        // Animate the triangle
+        animator.interpolator = LinearInterpolator()
+        animator.duration = 6000
+        animator.repeatMode = ValueAnimator.RESTART
+        animator.repeatCount = ValueAnimator.INFINITE
+        animator.addUpdateListener(object : ValueAnimator.AnimatorUpdateListener {
+            val transformMatrix = FloatArray(16)
+            override fun onAnimationUpdate(animator: ValueAnimator) {
+                val t = animator.animatedValue as Float
+                val radians = sin(t) * 3.0f * PI.toFloat()
+                Matrix.setRotateM(transformMatrix, 0, radians, 0.0f, 1.0f, 0.0f)
+                val tcm = engine.transformManager
+                tcm.setTransform(tcm.getInstance(renderable), transformMatrix)
+            }
+        })
+        animator.start()
+    }
+
+    override fun onResume() {
+        super.onResume()
+        choreographer.postFrameCallback(frameScheduler)
+        animator.start()
+//        cameraHelper.onResume()
+    }
+
+    override fun onPause() {
+        super.onPause()
+        choreographer.removeFrameCallback(frameScheduler)
+        animator.cancel()
+//        cameraHelper.onPause()
+    }
+
+    override fun onDestroy() {
+        super.onDestroy()
+
+        // Stop the animation and any pending frame
+        choreographer.removeFrameCallback(frameScheduler)
+        animator.cancel()
+
+        // Always detach the surface before destroying the engine
+        uiHelper.detach()
+
+        // Cleanup all resources
+        engine.destroyEntity(light)
+        engine.destroyEntity(renderable)
+        engine.destroyRenderer(renderer)
+        engine.destroyVertexBuffer(vertexBuffer)
+        engine.destroyIndexBuffer(indexBuffer)
+        engine.destroyMaterialInstance(materialInstance)
+        engine.destroyMaterial(material)
+        engine.destroyView(view)
+        engine.destroyScene(scene)
+        engine.destroyCameraComponent(camera.entity)
+
+        // Engine.destroyEntity() destroys Filament related resources only
+        // (components), not the entity itself
+        val entityManager = EntityManager.get()
+        entityManager.destroy(light)
+        entityManager.destroy(renderable)
+        entityManager.destroy(camera.entity)
+
+        // Destroying the engine will free up any resource you may have forgotten
+        // to destroy, but it's recommended to do the cleanup properly
+        engine.destroy()
+    }
+
+    inner class FrameCallback : Choreographer.FrameCallback {
+        override fun doFrame(frameTimeNanos: Long) {
+            // Schedule the next frame
+            choreographer.postFrameCallback(this)
+
+            // This check guarantees that we have a swap chain
+            if (uiHelper.isReadyToRender) {
+
+                if (myCount < 1) {
+                    val mybuffer: HardwareBuffer? = CanvasToHardwareBufferUtil.drawToHardwareBuffer(400, 400)
+                    mybuffer?.use { buffer : HardwareBuffer ->
+                                        // ... Use the buffer (e.g., create an EGLImage, pass to Vulkan, etc.) ...
+                                    Log.d(TAG, "Successfully created HardwareBuffer: $buffer. Now using it...")
+                                    // buffer.close() // 'use' handles this automatically
+                                    ExternalImage.setOnTexture(engine, filamentTexture!!, buffer, false)                                    
+
+                    } ?: run {
+                        Log.e(TAG, "Failed to create HardwareBuffer.")
+                    }
+                }
+                myCount ++;
+
+//                cameraHelper.pushExternalImageToFilament()
+
+                // If beginFrame() returns false you should skip the frame
+                // This means you are sending frames too quickly to the GPU
+                if (renderer.beginFrame(swapChain!!, frameTimeNanos)) {
+                    renderer.render(view)
+                    renderer.endFrame()
+                }
+            }
+        }
+    }
+
+    inner class SurfaceCallback : UiHelper.RendererCallback {
+        override fun onNativeWindowChanged(surface: Surface) {
+            swapChain?.let { engine.destroySwapChain(it) }
+            swapChain = engine.createSwapChain(surface)
+            displayHelper.attach(renderer, surfaceView.display)
+        }
+
+        override fun onDetachedFromSurface() {
+            displayHelper.detach()
+            swapChain?.let {
+                engine.destroySwapChain(it)
+                // Required to ensure we don't return before Filament is done executing the
+                // destroySwapChain command, otherwise Android might destroy the Surface
+                // too early
+                engine.flushAndWait()
+                swapChain = null
+            }
+        }
+
+        override fun onResized(width: Int, height: Int) {
+            val aspect = width.toDouble() / height.toDouble()
+            camera.setProjection(45.0, aspect, 0.1, 20.0, Camera.Fov.VERTICAL)
+
+            view.viewport = Viewport(0, 0, width, height)
+
+            FilamentHelper.synchronizePendingFrames(engine)
+        }
+    }
+
+    private fun readUncompressedAsset(@Suppress("SameParameterValue") assetName: String): ByteBuffer {
+        assets.openFd(assetName).use { fd ->
+            val input = fd.createInputStream()
+            val dst = ByteBuffer.allocate(fd.length.toInt())
+
+            val src = Channels.newChannel(input)
+            src.read(dst)
+            src.close()
+
+            return dst.apply { rewind() }
+        }
+    }
+
+    override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<String>, grantResults: IntArray) {
+//        if (!cameraHelper.onRequestPermissionsResult(requestCode, grantResults)) {
+//            this.onRequestPermissionsResult(requestCode, permissions, grantResults)
+//        }
+    }
+
+}

android/samples/sample-external-image/src/main/java/com/google/android/filament/externalimg/MainActivity.kt~

@@ -0,0 +1,446 @@
+/*
+ * Copyright (C) 2019 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.externalimg
+
+import android.animation.ValueAnimator
+import android.app.Activity
+import android.hardware.HardwareBuffer
+import android.opengl.Matrix
+import android.os.Bundle
+import android.view.Choreographer
+import android.view.Surface
+import android.view.SurfaceView
+import android.view.animation.LinearInterpolator
+import androidx.core.app.ActivityCompat
+
+import com.google.android.filament.*
+import com.google.android.filament.RenderableManager.*
+import com.google.android.filament.VertexBuffer.*
+import com.google.android.filament.android.DisplayHelper
+import com.google.android.filament.android.FilamentHelper
+import com.google.android.filament.android.UiHelper
+
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+import java.nio.channels.Channels
+
+import kotlin.math.*
+
+import android.util.Log
+
+class MainActivity : Activity(), ActivityCompat.OnRequestPermissionsResultCallback {
+    companion object {
+        init {
+            Filament.init()
+        }
+    }
+
+    private var TAG = "filament.externalimg"
+    
+    private lateinit var surfaceView: SurfaceView
+    private lateinit var uiHelper: UiHelper
+    private lateinit var displayHelper: DisplayHelper
+    private lateinit var choreographer: Choreographer
+
+    private lateinit var engine: Engine
+    private lateinit var renderer: Renderer
+    private lateinit var scene: Scene
+    private lateinit var view: View
+
+    // This is the Filament camera, not the phone camera. :)
+    private lateinit var camera: Camera
+
+    // Other Filament objects:
+    private lateinit var material: Material
+    private lateinit var materialInstance: MaterialInstance
+    private lateinit var vertexBuffer: VertexBuffer
+    private lateinit var indexBuffer: IndexBuffer
+
+    // Filament entity representing a renderable object
+    @Entity private var renderable = 0
+    @Entity private var light = 0
+
+    private var myCount : Int = 0
+
+    // A swap chain is Filament's representation of a surface
+    private var swapChain: SwapChain? = null
+
+    // Performs the rendering and schedules new frames
+    private val frameScheduler = FrameCallback()
+
+    private val animator = ValueAnimator.ofFloat(0.0f, 50.0f)
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        surfaceView = SurfaceView(this)
+        setContentView(surfaceView)
+
+        choreographer = Choreographer.getInstance()
+
+        displayHelper = DisplayHelper(this)
+
+        setupSurfaceView()
+        setupFilament()
+        setupView()
+        setupScene()
+
+//        cameraHelper = CameraHelper(this, engine, materialInstance)
+//        cameraHelper.openCamera()
+    }
+
+    private fun setupSurfaceView() {
+        uiHelper = UiHelper(UiHelper.ContextErrorPolicy.DONT_CHECK)
+        uiHelper.renderCallback = SurfaceCallback()
+        uiHelper.attachTo(surfaceView)
+    }
+
+    private fun setupFilament() {
+        engine = Engine.create()
+        renderer = engine.createRenderer()
+        scene = engine.createScene()
+        view = engine.createView()
+        camera = engine.createCamera(engine.entityManager.create())
+
+    }
+
+    private fun setupView() {
+        scene.skybox = Skybox.Builder().color(0.035f, 0.035f, 0.035f, 1.0f).build(engine)
+        view.camera = camera
+        view.scene = scene
+    }
+
+    private fun setupScene() {
+        loadMaterial()
+        setupMaterial()
+        createMesh()
+
+        // To create a renderable we first create a generic entity
+        renderable = EntityManager.get().create()
+
+        // We then create a renderable component on that entity
+        // A renderable is made of several primitives; in this case we declare only 1
+        // If we wanted each face of the cube to have a different material, we could
+        // declare 6 primitives (1 per face) and give each of them a different material
+        // instance, setup with different parameters
+        RenderableManager.Builder(1)
+                // Overall bounding box of the renderable
+                .boundingBox(Box(0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f))
+                // Sets the mesh data of the first primitive, 6 faces of 6 indices each
+                .geometry(0, PrimitiveType.TRIANGLES, vertexBuffer, indexBuffer, 0, 6 * 6)
+                // Sets the material of the first primitive
+                .material(0, materialInstance)
+                .build(engine, renderable)
+
+        // Add the entity to the scene to render it
+        scene.addEntity(renderable)
+
+        // We now need a light, let's create a directional light
+        light = EntityManager.get().create()
+
+        // Create a color from a temperature (5,500K)
+        val (r, g, b) = Colors.cct(5_500.0f)
+        LightManager.Builder(LightManager.Type.DIRECTIONAL)
+                .color(r, g, b)
+                // Intensity of the sun in lux on a clear day
+                .intensity(110_000.0f)
+                // The direction is normalized on our behalf
+                .direction(0.0f, -0.5f, -1.0f)
+                .castShadows(true)
+                .build(engine, light)
+
+        // Add the entity to the scene to light it
+        scene.addEntity(light)
+
+        // Set the exposure on the camera, this exposure follows the sunny f/16 rule
+        // Since we've defined a light that has the same intensity as the sun, it
+        // guarantees a proper exposure
+        camera.setExposure(16.0f, 1.0f / 125.0f, 100.0f)
+
+        // Move the camera back to see the object
+        camera.lookAt(0.0, 0.0, 6.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0)
+
+        startAnimation()
+    }
+
+    private fun loadMaterial() {
+        readUncompressedAsset("materials/lit.filamat").let {
+            material = Material.Builder().payload(it, it.remaining()).build(engine)
+        }
+    }
+
+    private fun setupMaterial() {
+        materialInstance = material.createInstance()
+        materialInstance.setParameter("baseColor", Colors.RgbType.SRGB, 1.0f, 0.85f, 0.57f)
+        materialInstance.setParameter("roughness", 0.3f)
+    }
+
+    private fun createMesh() {
+        val floatSize = 4
+        val shortSize = 2
+        // A vertex is a position + a tangent frame:
+        // 3 floats for XYZ position, 4 floats for normal+tangents (quaternion)
+        val vertexSize = 3 * floatSize + 4 * floatSize
+
+        // Define a vertex and a function to put a vertex in a ByteBuffer
+        @Suppress("ArrayInDataClass")
+        data class Vertex(val x: Float, val y: Float, val z: Float, val tangents: FloatArray)
+        fun ByteBuffer.put(v: Vertex): ByteBuffer {
+            putFloat(v.x)
+            putFloat(v.y)
+            putFloat(v.z)
+            v.tangents.forEach { putFloat(it) }
+            return this
+        }
+
+        // 6 faces, 4 vertices per face
+        val vertexCount = 6 * 4
+
+        // Create tangent frames, one per face
+        val tfPX = FloatArray(4)
+        val tfNX = FloatArray(4)
+        val tfPY = FloatArray(4)
+        val tfNY = FloatArray(4)
+        val tfPZ = FloatArray(4)
+        val tfNZ = FloatArray(4)
+
+        MathUtils.packTangentFrame( 0.0f,  1.0f, 0.0f, 0.0f, 0.0f, -1.0f,  1.0f,  0.0f,  0.0f, tfPX)
+        MathUtils.packTangentFrame( 0.0f,  1.0f, 0.0f, 0.0f, 0.0f, -1.0f, -1.0f,  0.0f,  0.0f, tfNX)
+        MathUtils.packTangentFrame(-1.0f,  0.0f, 0.0f, 0.0f, 0.0f, -1.0f,  0.0f,  1.0f,  0.0f, tfPY)
+        MathUtils.packTangentFrame(-1.0f,  0.0f, 0.0f, 0.0f, 0.0f,  1.0f,  0.0f, -1.0f,  0.0f, tfNY)
+        MathUtils.packTangentFrame( 0.0f,  1.0f, 0.0f, 1.0f, 0.0f,  0.0f,  0.0f,  0.0f,  1.0f, tfPZ)
+        MathUtils.packTangentFrame( 0.0f, -1.0f, 0.0f, 1.0f, 0.0f,  0.0f,  0.0f,  0.0f, -1.0f, tfNZ)
+
+        val vertexData = ByteBuffer.allocate(vertexCount * vertexSize)
+                // It is important to respect the native byte order
+                .order(ByteOrder.nativeOrder())
+                // Face -Z
+                .put(Vertex(-1.5f, -1.5f, -1.0f, tfNZ))
+                .put(Vertex(-1.5f,  1.5f, -1.0f, tfNZ))
+                .put(Vertex( 1.5f,  1.5f, -1.0f, tfNZ))
+                .put(Vertex( 1.5f, -1.5f, -1.0f, tfNZ))
+                // Face +X
+                .put(Vertex( 1.5f, -1.5f, -1.0f, tfPX))
+                .put(Vertex( 1.5f,  1.5f, -1.0f, tfPX))
+                .put(Vertex( 1.0f,  1.0f,  1.0f, tfPX))
+                .put(Vertex( 1.0f, -1.0f,  1.0f, tfPX))
+                // Face +Z
+                .put(Vertex(-1.0f, -1.0f,  1.0f, tfPZ))
+                .put(Vertex( 1.0f, -1.0f,  1.0f, tfPZ))
+                .put(Vertex( 1.0f,  1.0f,  1.0f, tfPZ))
+                .put(Vertex(-1.0f,  1.0f,  1.0f, tfPZ))
+                // Face -X
+                .put(Vertex(-1.0f, -1.0f,  1.0f, tfNX))
+                .put(Vertex(-1.0f,  1.0f,  1.0f, tfNX))
+                .put(Vertex(-1.5f,  1.5f, -1.0f, tfNX))
+                .put(Vertex(-1.5f, -1.5f, -1.0f, tfNX))
+                // Face -Y
+                .put(Vertex(-1.0f, -1.0f,  1.0f, tfNY))
+                .put(Vertex(-1.5f, -1.5f, -1.0f, tfNY))
+                .put(Vertex( 1.5f, -1.5f, -1.0f, tfNY))
+                .put(Vertex( 1.0f, -1.0f,  1.0f, tfNY))
+                // Face +Y
+                .put(Vertex(-1.5f,  1.5f, -1.0f, tfPY))
+                .put(Vertex(-1.0f,  1.0f,  1.0f, tfPY))
+                .put(Vertex( 1.0f,  1.0f,  1.0f, tfPY))
+                .put(Vertex( 1.5f,  1.5f, -1.0f, tfPY))
+                // Make sure the cursor is pointing in the right place in the byte buffer
+                .flip()
+
+        // Declare the layout of our mesh
+        vertexBuffer = VertexBuffer.Builder()
+                .bufferCount(1)
+                .vertexCount(vertexCount)
+                // Because we interleave position and color data we must specify offset and stride
+                // We could use de-interleaved data by declaring two buffers and giving each
+                // attribute a different buffer index
+                .attribute(VertexAttribute.POSITION, 0, AttributeType.FLOAT3, 0,             vertexSize)
+                .attribute(VertexAttribute.TANGENTS, 0, AttributeType.FLOAT4, 3 * floatSize, vertexSize)
+                .build(engine)
+
+        // Feed the vertex data to the mesh
+        // We only set 1 buffer because the data is interleaved
+        vertexBuffer.setBufferAt(engine, 0, vertexData)
+
+        // Create the indices
+        val indexData = ByteBuffer.allocate(6 * 2 * 3 * shortSize)
+                .order(ByteOrder.nativeOrder())
+        repeat(6) {
+            val i = (it * 4).toShort()
+            indexData
+                    .putShort(i).putShort((i + 1).toShort()).putShort((i + 2).toShort())
+                    .putShort(i).putShort((i + 2).toShort()).putShort((i + 3).toShort())
+        }
+        indexData.flip()
+
+        // 6 faces, 2 triangles per face,
+        indexBuffer = IndexBuffer.Builder()
+                .indexCount(vertexCount * 2)
+                .bufferType(IndexBuffer.Builder.IndexType.USHORT)
+                .build(engine)
+        indexBuffer.setBuffer(engine, indexData)
+    }
+
+    private fun startAnimation() {
+        // Animate the triangle
+        animator.interpolator = LinearInterpolator()
+        animator.duration = 6000
+        animator.repeatMode = ValueAnimator.RESTART
+        animator.repeatCount = ValueAnimator.INFINITE
+        animator.addUpdateListener(object : ValueAnimator.AnimatorUpdateListener {
+            val transformMatrix = FloatArray(16)
+            override fun onAnimationUpdate(animator: ValueAnimator) {
+                val t = animator.animatedValue as Float
+                val radians = sin(t) * 3.0f * PI.toFloat()
+                Matrix.setRotateM(transformMatrix, 0, radians, 0.0f, 1.0f, 0.0f)
+                val tcm = engine.transformManager
+                tcm.setTransform(tcm.getInstance(renderable), transformMatrix)
+            }
+        })
+        animator.start()
+    }
+
+    override fun onResume() {
+        super.onResume()
+        choreographer.postFrameCallback(frameScheduler)
+        animator.start()
+//        cameraHelper.onResume()
+    }
+
+    override fun onPause() {
+        super.onPause()
+        choreographer.removeFrameCallback(frameScheduler)
+        animator.cancel()
+//        cameraHelper.onPause()
+    }
+
+    override fun onDestroy() {
+        super.onDestroy()
+
+        // Stop the animation and any pending frame
+        choreographer.removeFrameCallback(frameScheduler)
+        animator.cancel()
+
+        // Always detach the surface before destroying the engine
+        uiHelper.detach()
+
+        // Cleanup all resources
+        engine.destroyEntity(light)
+        engine.destroyEntity(renderable)
+        engine.destroyRenderer(renderer)
+        engine.destroyVertexBuffer(vertexBuffer)
+        engine.destroyIndexBuffer(indexBuffer)
+        engine.destroyMaterialInstance(materialInstance)
+        engine.destroyMaterial(material)
+        engine.destroyView(view)
+        engine.destroyScene(scene)
+        engine.destroyCameraComponent(camera.entity)
+
+        // Engine.destroyEntity() destroys Filament related resources only
+        // (components), not the entity itself
+        val entityManager = EntityManager.get()
+        entityManager.destroy(light)
+        entityManager.destroy(renderable)
+        entityManager.destroy(camera.entity)
+
+        // Destroying the engine will free up any resource you may have forgotten
+        // to destroy, but it's recommended to do the cleanup properly
+        engine.destroy()
+    }
+
+    inner class FrameCallback : Choreographer.FrameCallback {
+        override fun doFrame(frameTimeNanos: Long) {
+            // Schedule the next frame
+            choreographer.postFrameCallback(this)
+
+            // This check guarantees that we have a swap chain
+            if (uiHelper.isReadyToRender) {
+
+                if (myCount < 1) {
+                    val mybuffer: HardwareBuffer? = CanvasToHardwareBufferUtil.drawToHardwareBuffer(400, 400)
+                    mybuffer?.use { buffer : HardwareBuffer ->
+                                        // ... Use the buffer (e.g., create an EGLImage, pass to Vulkan, etc.) ...
+                                    Log.d(TAG, "Successfully created HardwareBuffer: $buffer. Now using it...")
+                                    // buffer.close() // 'use' handles this automatically
+                                    
+                    } ?: run {
+                        Log.e(TAG, "Failed to create HardwareBuffer.")
+                    }
+                }
+                myCount ++;
+                
+//                cameraHelper.pushExternalImageToFilament()
+
+                // If beginFrame() returns false you should skip the frame
+                // This means you are sending frames too quickly to the GPU
+                if (renderer.beginFrame(swapChain!!, frameTimeNanos)) {
+                    renderer.render(view)
+                    renderer.endFrame()
+                }
+            }
+        }
+    }
+
+    inner class SurfaceCallback : UiHelper.RendererCallback {
+        override fun onNativeWindowChanged(surface: Surface) {
+            swapChain?.let { engine.destroySwapChain(it) }
+            swapChain = engine.createSwapChain(surface)
+            displayHelper.attach(renderer, surfaceView.display)
+        }
+
+        override fun onDetachedFromSurface() {
+            displayHelper.detach()
+            swapChain?.let {
+                engine.destroySwapChain(it)
+                // Required to ensure we don't return before Filament is done executing the
+                // destroySwapChain command, otherwise Android might destroy the Surface
+                // too early
+                engine.flushAndWait()
+                swapChain = null
+            }
+        }
+
+        override fun onResized(width: Int, height: Int) {
+            val aspect = width.toDouble() / height.toDouble()
+            camera.setProjection(45.0, aspect, 0.1, 20.0, Camera.Fov.VERTICAL)
+
+            view.viewport = Viewport(0, 0, width, height)
+
+            FilamentHelper.synchronizePendingFrames(engine)
+        }
+    }
+
+    private fun readUncompressedAsset(@Suppress("SameParameterValue") assetName: String): ByteBuffer {
+        assets.openFd(assetName).use { fd ->
+            val input = fd.createInputStream()
+            val dst = ByteBuffer.allocate(fd.length.toInt())
+
+            val src = Channels.newChannel(input)
+            src.read(dst)
+            src.close()
+
+            return dst.apply { rewind() }
+        }
+    }
+
+    override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<String>, grantResults: IntArray) {
+//        if (!cameraHelper.onRequestPermissionsResult(requestCode, grantResults)) {
+//            this.onRequestPermissionsResult(requestCode, permissions, grantResults)
+//        }
+    }
+
+}

android/samples/sample-external-image/src/main/materials/lit.mat

@@ -0,0 +1,73 @@
+// Simple lit material that defines 3 parameters:
+// - baseColor
+// - roughness
+// - metallic
+//
+// These parameters can be used by the application to change the appearance of the material.
+//
+// This source material must be compiled to a binary material using the matc tool.
+// The command used to compile this material is:
+// matc -p mobile -a opengl -o app/src/main/assets/lit.filamat app/src/materials/lit.mat
+//
+// See build.gradle for an example of how to compile materials automatically
+// Please refer to the documentation for more information about matc and the materials system.
+
+material {
+    name : lit,
+
+    // Dynamic lighting is enabled on this material
+    shadingModel : lit,
+
+    // We don't need to declare a "requires" array, lit materials
+    // always requires the "tangents" vertex attribute (the normal
+    // is required for lighting, tangent/bitangent for normal mapping
+    // and anisotropy)
+
+    // Custom vertex shader outputs
+    variables : [
+        uv
+    ],
+
+    // List of parameters exposed by this material
+    parameters : [
+        // The color must be passed in linear space, not sRGB
+        {
+            type : float3,
+            name : baseColor
+        },
+        {
+            type : float,
+            name : roughness
+        },
+        {
+            type : samplerExternal,
+            name : videoTexture
+        },
+        {
+            type : mat4,
+            name : textureTransform
+        }
+    ],
+}
+
+vertex {
+    void materialVertex(inout MaterialVertexInputs material) {
+        material.uv = 0.5 * (getPosition() + vec4(1));
+    }
+}
+
+fragment {
+    void material(inout MaterialInputs material) {
+        prepareMaterial(material);
+        material.roughness = materialParams.roughness;
+        material.metallic = 0.0;
+
+        // Apply the video stream to the +Z face on the cube.
+        if (variable_uv.z >= 1.0) {
+            vec2 uv = (materialParams.textureTransform * vec4(variable_uv.xy, 0, 1)).xy;
+            material.baseColor.rgb = inverseTonemapSRGB(texture(materialParams_videoTexture, uv).rgb);
+        } else {
+            material.baseColor.rgb = materialParams.baseColor;
+        }
+    }
+}

android/samples/sample-external-image/src/main/res/drawable-v24/ic_launcher_foreground.xml

@@ -0,0 +1,34 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:aapt="http://schemas.android.com/aapt"
+    android:width="108dp"
+    android:height="108dp"
+    android:viewportHeight="108"
+    android:viewportWidth="108">
+  <path
+      android:fillType="evenOdd"
+      android:pathData="M32,64C32,64 38.39,52.99 44.13,50.95C51.37,48.37 70.14,49.57 70.14,49.57L108.26,87.69L108,109.01L75.97,107.97L32,64Z"
+      android:strokeColor="#00000000"
+      android:strokeWidth="1">
+    <aapt:attr name="android:fillColor">
+      <gradient
+          android:endX="78.5885"
+          android:endY="90.9159"
+          android:startX="48.7653"
+          android:startY="61.0927"
+          android:type="linear">
+        <item
+            android:color="#44000000"
+            android:offset="0.0"/>
+        <item
+            android:color="#00000000"
+            android:offset="1.0"/>
+      </gradient>
+    </aapt:attr>
+  </path>
+  <path
+      android:fillColor="#FFFFFF"
+      android:fillType="nonZero"
+      android:pathData="M66.94,46.02L66.94,46.02C72.44,50.07 76,56.61 76,64L32,64C32,56.61 35.56,50.11 40.98,46.06L36.18,41.19C35.45,40.45 35.45,39.3 36.18,38.56C36.91,37.81 38.05,37.81 38.78,38.56L44.25,44.05C47.18,42.57 50.48,41.71 54,41.71C57.48,41.71 60.78,42.57 63.68,44.05L69.11,38.56C69.84,37.81 70.98,37.81 71.71,38.56C72.44,39.3 72.44,40.45 71.71,41.19L66.94,46.02ZM62.94,56.92C64.08,56.92 65,56.01 65,54.88C65,53.76 64.08,52.85 62.94,52.85C61.8,52.85 60.88,53.76 60.88,54.88C60.88,56.01 61.8,56.92 62.94,56.92ZM45.06,56.92C46.2,56.92 47.13,56.01 47.13,54.88C47.13,53.76 46.2,52.85 45.06,52.85C43.92,52.85 43,53.76 43,54.88C43,56.01 43.92,56.92 45.06,56.92Z"
+      android:strokeColor="#00000000"
+      android:strokeWidth="1"/>
+</vector>

android/samples/sample-external-image/src/main/res/drawable/ic_launcher_background.xml

@@ -0,0 +1,171 @@
+<?xml version="1.0" encoding="utf-8"?>
+<vector
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="108dp"
+    android:height="108dp"
+    android:viewportHeight="108"
+    android:viewportWidth="108">
+  <path
+      android:fillColor="#26A69A"
+      android:pathData="M0,0h108v108h-108z"/>
+  <path
+      android:fillColor="#00000000"
+      android:pathData="M9,0L9,108"
+      android:strokeColor="#33FFFFFF"
+      android:strokeWidth="0.8"/>
+  <path
+      android:fillColor="#00000000"
+      android:pathData="M19,0L19,108"
+      android:strokeColor="#33FFFFFF"
+      android:strokeWidth="0.8"/>
+  <path
+      android:fillColor="#00000000"
+      android:pathData="M29,0L29,108"
+      android:strokeColor="#33FFFFFF"
+      android:strokeWidth="0.8"/>
+  <path
+      android:fillColor="#00000000"
+      android:pathData="M39,0L39,108"
+      android:strokeColor="#33FFFFFF"
+      android:strokeWidth="0.8"/>
+  <path
+      android:fillColor="#00000000"
+      android:pathData="M49,0L49,108"
+      android:strokeColor="#33FFFFFF"
+      android:strokeWidth="0.8"/>
+  <path
+      android:fillColor="#00000000"
+      android:pathData="M59,0L59,108"
+      android:strokeColor="#33FFFFFF"
+      android:strokeWidth="0.8"/>
+  <path
+      android:fillColor="#00000000"
+      android:pathData="M69,0L69,108"
+      android:strokeColor="#33FFFFFF"
+      android:strokeWidth="0.8"/>
+  <path
+      android:fillColor="#00000000"
+      android:pathData="M79,0L79,108"
+      android:strokeColor="#33FFFFFF"
+      android:strokeWidth="0.8"/>
+  <path
+      android:fillColor="#00000000"
+      android:pathData="M89,0L89,108"
+      android:strokeColor="#33FFFFFF"
+      android:strokeWidth="0.8"/>
+  <path
+      android:fillColor="#00000000"
+      android:pathData="M99,0L99,108"
+      android:strokeColor="#33FFFFFF"
+      android:strokeWidth="0.8"/>
+  <path
+      android:fillColor="#00000000"
+      android:pathData="M0,9L108,9"
+      android:strokeColor="#33FFFFFF"
+      android:strokeWidth="0.8"/>
+  <path
+      android:fillColor="#00000000"
+      android:pathData="M0,19L108,19"
+      android:strokeColor="#33FFFFFF"
+      android:strokeWidth="0.8"/>
+  <path
+      android:fillColor="#00000000"
+      android:pathData="M0,29L108,29"
+      android:strokeColor="#33FFFFFF"
+      android:strokeWidth="0.8"/>
+  <path
+      android:fillColor="#00000000"
+      android:pathData="M0,39L108,39"
+      android:strokeColor="#33FFFFFF"
+      android:strokeWidth="0.8"/>
+  <path
+      android:fillColor="#00000000"
+      android:pathData="M0,49L108,49"
+      android:strokeColor="#33FFFFFF"
+      android:strokeWidth="0.8"/>
+  <path
+      android:fillColor="#00000000"
+      android:pathData="M0,59L108,59"
+      android:strokeColor="#33FFFFFF"
+      android:strokeWidth="0.8"/>
+  <path
+      android:fillColor="#00000000"
+      android:pathData="M0,69L108,69"
+      android:strokeColor="#33FFFFFF"
+      android:strokeWidth="0.8"/>
+  <path
+      android:fillColor="#00000000"
+      android:pathData="M0,79L108,79"
+      android:strokeColor="#33FFFFFF"
+      android:strokeWidth="0.8"/>
+  <path
+      android:fillColor="#00000000"
+      android:pathData="M0,89L108,89"
+      android:strokeColor="#33FFFFFF"
+      android:strokeWidth="0.8"/>
+  <path
+      android:fillColor="#00000000"
+      android:pathData="M0,99L108,99"
+      android:strokeColor="#33FFFFFF"
+      android:strokeWidth="0.8"/>
+  <path
+      android:fillColor="#00000000"
+      android:pathData="M19,29L89,29"
+      android:strokeColor="#33FFFFFF"
+      android:strokeWidth="0.8"/>
+  <path
+      android:fillColor="#00000000"
+      android:pathData="M19,39L89,39"
+      android:strokeColor="#33FFFFFF"
+      android:strokeWidth="0.8"/>
+  <path
+      android:fillColor="#00000000"
+      android:pathData="M19,49L89,49"
+      android:strokeColor="#33FFFFFF"
+      android:strokeWidth="0.8"/>
+  <path
+      android:fillColor="#00000000"
+      android:pathData="M19,59L89,59"
+      android:strokeColor="#33FFFFFF"
+      android:strokeWidth="0.8"/>
+  <path
+      android:fillColor="#00000000"
+      android:pathData="M19,69L89,69"
+      android:strokeColor="#33FFFFFF"
+      android:strokeWidth="0.8"/>
+  <path
+      android:fillColor="#00000000"
+      android:pathData="M19,79L89,79"
+      android:strokeColor="#33FFFFFF"
+      android:strokeWidth="0.8"/>
+  <path
+      android:fillColor="#00000000"
+      android:pathData="M29,19L29,89"
+      android:strokeColor="#33FFFFFF"
+      android:strokeWidth="0.8"/>
+  <path
+      android:fillColor="#00000000"
+      android:pathData="M39,19L39,89"
+      android:strokeColor="#33FFFFFF"
+      android:strokeWidth="0.8"/>
+  <path
+      android:fillColor="#00000000"
+      android:pathData="M49,19L49,89"
+      android:strokeColor="#33FFFFFF"
+      android:strokeWidth="0.8"/>
+  <path
+      android:fillColor="#00000000"
+      android:pathData="M59,19L59,89"
+      android:strokeColor="#33FFFFFF"
+      android:strokeWidth="0.8"/>
+  <path
+      android:fillColor="#00000000"
+      android:pathData="M69,19L69,89"
+      android:strokeColor="#33FFFFFF"
+      android:strokeWidth="0.8"/>
+  <path
+      android:fillColor="#00000000"
+      android:pathData="M79,19L79,89"
+      android:strokeColor="#33FFFFFF"
+      android:strokeWidth="0.8"/>
+</vector>

android/samples/sample-external-image/src/main/res/mipmap-anydpi-v26/ic_launcher.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+  <background android:drawable="@drawable/ic_launcher_background"/>
+  <foreground android:drawable="@drawable/ic_launcher_foreground"/>
+</adaptive-icon>

android/samples/sample-external-image/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+  <background android:drawable="@drawable/ic_launcher_background"/>
+  <foreground android:drawable="@drawable/ic_launcher_foreground"/>
+</adaptive-icon>

android/samples/sample-external-image/src/main/res/values/colors.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+  <color name="colorPrimary">#3F51B5</color>
+  <color name="colorPrimaryDark">#303F9F</color>
+  <color name="colorAccent">#FF4081</color>
+</resources>

android/samples/sample-external-image/src/main/res/values/strings.xml

@@ -0,0 +1,3 @@
+<resources>
+  <string name="app_name">External Image</string>
+</resources>

android/samples/sample-external-image/src/main/res/values/strings.xml~

@@ -0,0 +1,3 @@
+<resources>
+  <string name="app_name">Hello Camera</string>
+</resources>

android/samples/sample-external-image/src/main/res/values/styles.xml

@@ -0,0 +1,8 @@
+<resources>
+
+  <!-- Base application theme. -->
+  <style name="AppTheme" parent="android:Theme.Material.Light.DarkActionBar">
+    <!-- Customize your theme here. -->
+  </style>
+
+</resources>

android/settings.gradle

@@ -18,5 +18,6 @@ include ':samples:sample-stream-test'
 include ':samples:sample-texture-view'
 include ':samples:sample-textured-object'
 include ':samples:sample-transparent-view'
+include ':samples:sample-external-image'
 
 rootProject.name = 'filament'

build.sh

@@ -200,9 +200,8 @@ WEBGPU_ANDROID_GRADLE_OPTION=""
 EGL_ON_LINUX_OPTION="-DFILAMENT_SUPPORTS_EGL_ON_LINUX=OFF"
 
 MATDBG_OPTION="-DFILAMENT_ENABLE_MATDBG=OFF"
-MATDBG_GRADLE_OPTION=""
 FGVIEWER_OPTION="-DFILAMENT_ENABLE_FGVIEWER=OFF"
-FGVIEWER_GRADLE_OPTION=""
+MATDBG_GRADLE_OPTION=""
 
 MATOPT_OPTION=""
 MATOPT_GRADLE_OPTION=""
@@ -534,7 +533,6 @@ function build_android {
             ${VULKAN_ANDROID_GRADLE_OPTION} \
             ${WEBGPU_ANDROID_GRADLE_OPTION} \
             ${MATDBG_GRADLE_OPTION} \
-            ${FGVIEWER_GRADLE_OPTION} \
             ${MATOPT_GRADLE_OPTION} \
             :filament-android:assembleDebug \
             :gltfio-android:assembleDebug \
@@ -586,7 +584,6 @@ function build_android {
             ${VULKAN_ANDROID_GRADLE_OPTION} \
             ${WEBGPU_ANDROID_GRADLE_OPTION} \
             ${MATDBG_GRADLE_OPTION} \
-            ${FGVIEWER_GRADLE_OPTION} \
             ${MATOPT_GRADLE_OPTION} \
             :filament-android:assembleRelease \
             :gltfio-android:assembleRelease \

filament/backend/include/backend/DriverEnums.h

@@ -256,18 +256,16 @@ struct DescriptorSetLayoutBinding {
     DescriptorFlags flags = DescriptorFlags::NONE;
     uint16_t count = 0;
 
-    //  TODO: uncomment when needed.  Note that this class is used as hash key.  We need to ensure
-    //  no uninitialized padding bytes.
-    //    uint8_t externalSamplerDataIndex = EXTERNAL_SAMPLER_DATA_INDEX_UNUSED;
+    uint8_t externalSamplerDataIndex = EXTERNAL_SAMPLER_DATA_INDEX_UNUSED;
 
-    friend inline bool operator==(DescriptorSetLayoutBinding const& lhs,
+    friend inline bool operator==(
+            DescriptorSetLayoutBinding const& lhs,
             DescriptorSetLayoutBinding const& rhs) noexcept {
         return lhs.type == rhs.type &&
                lhs.flags == rhs.flags &&
                lhs.count == rhs.count &&
-               lhs.stageFlags == rhs.stageFlags;
-//               lhs.stageFlags == rhs.stageFlags &&
-//               lhs.externalSamplerDataIndex == rhs.externalSamplerDataIndex;
+               lhs.stageFlags == rhs.stageFlags &&
+               lhs.externalSamplerDataIndex == rhs.externalSamplerDataIndex;
     }
 };
 
@@ -1140,9 +1138,7 @@ static_assert(sizeof(ExternalSamplerDatum) == 12);
 
 struct DescriptorSetLayout {
     utils::FixedCapacityVector<DescriptorSetLayoutBinding> bindings;
-
-//  TODO: uncomment when needed
-//    utils::FixedCapacityVector<ExternalSamplerDatum> externalSamplerData;
+    utils::FixedCapacityVector<ExternalSamplerDatum> externalSamplerData;
 };
 
 //! blending equation function

filament/backend/src/noop/NoopDriver.cpp

@@ -241,7 +241,7 @@ size_t NoopDriver::getMaxUniformBufferSize() {
 }
 
 size_t NoopDriver::getMaxTextureSize(SamplerType target) {
-    return 4096u;
+    return 2048u;
 }
 
 size_t NoopDriver::getMaxArrayTextureLayers() {

filament/backend/src/vulkan/VulkanConstants.h

@@ -93,7 +93,7 @@
 #endif
 
 #ifndef NDEBUG
-#define FVK_DEBUG_FLAGS (FVK_DEBUG_PERFORMANCE | FVK_DEBUG_FORWARDED_FLAG)
+#define FVK_DEBUG_FLAGS (FVK_DEBUG_PERFORMANCE | FVK_DEBUG_FORWARDED_FLAG | FVK_DEBUG_VALIDATION)
 #else
 #define FVK_DEBUG_FLAGS 0
 #endif

filament/backend/src/vulkan/VulkanDriver.cpp

@@ -1057,7 +1057,7 @@ bool VulkanDriver::isDepthStencilBlitSupported(TextureFormat format) {
            formats.end();
 }
 
-bool VulkanDriver::isProtectedTexturesSupported() { return isProtectedContentSupported(); }
+bool VulkanDriver::isProtectedTexturesSupported() { return false; }
 
 bool VulkanDriver::isDepthClampSupported() {
     return mContext.isDepthClampSupported();
@@ -1146,7 +1146,7 @@ size_t VulkanDriver::getMaxUniformBufferSize() {
 
 size_t VulkanDriver::getMaxTextureSize(SamplerType) {
     // TODO: return the actual size instead of hardcoded value
-    return 4096;
+    return 2048;
 }
 
 size_t VulkanDriver::getMaxArrayTextureLayers() {

filament/backend/src/vulkan/platform/VulkanPlatform.cpp

@@ -736,6 +736,10 @@ Driver* VulkanPlatform::createDriver(void* sharedContext,
     chainStruct(&context.mPhysicalDeviceFeatures, &queryProtectedMemoryFeatures);
     chainStruct(&context.mPhysicalDeviceProperties, &protectedMemoryProperties);
 
+    // We know we need to allocate the protected version of the VK objects
+    context.mProtectedMemorySupported =
+            static_cast<bool>(queryProtectedMemoryFeatures.protectedMemory);
+
     // Initialize the following fields: physicalDeviceProperties, memoryProperties,
     // physicalDeviceFeatures, graphicsQueueFamilyIndex.
     vkGetPhysicalDeviceProperties2(mImpl->mPhysicalDevice, &context.mPhysicalDeviceProperties);
@@ -755,10 +759,6 @@ Driver* VulkanPlatform::createDriver(void* sharedContext,
         mImpl->mGraphicsQueueIndex = 0;
     }
 
-    // We know we need to allocate the protected version of the VK objects
-    context.mProtectedMemorySupported =
-            static_cast<bool>(queryProtectedMemoryFeatures.protectedMemory);
-
     if (context.mProtectedMemorySupported) {
         mImpl->mProtectedGraphicsQueueFamilyIndex = identifyGraphicsQueueFamilyIndex(
                 mImpl->mPhysicalDevice, (VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_PROTECTED_BIT));

filament/src/details/ColorGrading.cpp

@@ -664,8 +664,7 @@ FColorGrading::FColorGrading(FEngine& engine, const Builder& builder) {
     // spaces are the same, but we currently don't check that. We must revise these conditions if we
     // ever handle this case.
     mIsOneDimensional = !builder->hasAdjustments && !builder->luminanceScaling
-            && builder->toneMapper->isOneDimensional()
-            && engine.features.engine.color_grading.use_1d_lut;
+            && builder->toneMapper->isOneDimensional();
     mIsLDR = mIsOneDimensional && builder->toneMapper->isLDR();
 
     const Config config = {

filament/src/details/Engine.h

@@ -687,9 +687,6 @@ public:
 
     struct {
         struct {
-            struct {
-                bool use_1d_lut = false;
-            } color_grading;
             struct {
                 bool use_shadow_atlas = false;
             } shadows;
@@ -722,9 +719,6 @@ public:
             { "backend.opengl.assert_native_window_is_valid",
               "Asserts that the ANativeWindow is valid when rendering starts.",
               &features.backend.opengl.assert_native_window_is_valid, true },
-            { "engine.color_grading.use_1d_lut",
-              "Uses a 1D LUT for color grading.",
-              &features.engine.color_grading.use_1d_lut, false },
             { "engine.shadows.use_shadow_atlas",
               "Uses an array of atlases to store shadow maps.",
               &features.engine.shadows.use_shadow_atlas, false },

filament/src/materials/dof/dofMedian.mat

@@ -88,12 +88,7 @@ void minLeftMaxRight(inout vec4 a, inout vec4 b, inout vec4 c, inout vec4 d, ino
 
 // - we can't use a function because offset must be a constant expression
 // - we can't use line continuation because that's not supported on desktop
-#ifdef TARGET_WEBGPU_ENVIRONMENT
-//WebGPU can not handle texelFetchOffset without an error about "ConstOffset is only permitted...".
-#define makeSample(ij, o) vec4(texelFetch(materialParams_dof, ij+o, 0).rgb, texelFetch(materialParams_alpha, ij+o, 0).r)
-#else
 #define makeSample(ij, o) vec4(texelFetchOffset(materialParams_dof, ij, 0, o).rgb, texelFetchOffset(materialParams_alpha, ij, 0, o).r)
-#endif
 
 vec4 median(ivec2 ij) {
     vec4 v[9];

libs/filabridge/include/filament/MaterialEnums.h

@@ -28,7 +28,7 @@
 namespace filament {
 
 // update this when a new version of filament wouldn't work with older materials
-static constexpr size_t MATERIAL_VERSION = 58;
+static constexpr size_t MATERIAL_VERSION = 57;
 
 /**
  * Supported shading models

libs/filamat/src/GLSLPostProcessor.cpp

@@ -517,104 +517,29 @@ void GLSLPostProcessor::spirvToMsl(const SpirvBlob* spirv, std::string* outMsl,
         MetalArgumentBuffer::destroy(&argBuffer);
     }
 }
-void GLSLPostProcessor::rebindImageSamplerForWGSL(std::vector<uint32_t>& spirv) {
-    constexpr size_t HEADER_SIZE = 5;
-    size_t const dataSize = spirv.size();
-    uint32_t* data = spirv.data();
-
-    struct Descriptor {
-        uint32_t binding = 0xFFFFFFFF;
-        bool fixed = false;
-    };
-
-    std::unordered_map<uint32_t, Descriptor> descriptors;
-    std::set<uint32_t> unidentifiedLoadTargets;
-    std::vector<uint32_t> bindingTargets;
-
-    auto getDesc = [&](uint32_t var) -> Descriptor& {
-        using itertype = std::unordered_map<uint32_t, Descriptor>::iterator;
-        itertype itr;
-        if (itr = descriptors.find(var); itr == descriptors.end()) {
-            itr = descriptors.insert({var, {}}).first;
-        }
-        return itr->second;
-    };
-
-    auto pass = [&](uint32_t targetOp, std::function<void(uint32_t)> f) {
-        for (uint32_t cursor = HEADER_SIZE, cursorEnd = dataSize; cursor < cursorEnd;) {
-            uint32_t const firstWord = data[cursor];
-            uint32_t const wordCount = firstWord >> 16;
-            uint32_t const op = firstWord & 0x0000FFFF;
-            if (targetOp == op) {
-                f(cursor+1);
-            }
-            cursor += wordCount;
-        }
-    };
-
-    uint32_t samplerTypeId = 0;
-    pass(spv::Op::OpName, [&](uint32_t pos) {
-        auto target = data[pos];
-        char* name = (char*)&data[pos+1];
-        std::string_view view(name);
-        if (view.find("_sampler") != std::string_view::npos) {
-            unidentifiedLoadTargets.insert(target);
-        }
-});
-
-
-    // Write out the offsetted bindings
-    pass(spv::Op::OpDecorate, [&](uint32_t pos) {
-        uint32_t const type = data[pos + 1];
-        if (type == spv::Decoration::DecorationBinding) {
-            uint32_t const targetVar = data[pos];
-            if (unidentifiedLoadTargets.find(targetVar) != unidentifiedLoadTargets.end()) {
-                data[pos + 2] = data[pos + 2]*2 + 1;
-            }
-            else {
-                data[pos + 2] = data[pos + 2] *2;
-            }
-        }
-    });
-}
 
 bool GLSLPostProcessor::spirvToWgsl(SpirvBlob *spirv, std::string *outWsl) {
 #if FILAMENT_SUPPORTS_WEBGPU
-    //We need to run some opt-passes at all times to transpile to WGSL
-    auto optimizer = createEmptyOptimizer();
-    optimizer->RegisterPass(CreateSplitCombinedImageSamplerPass());
-    //optimizer->RegisterPass(CreateResolveBindingConflictsPass());
+    // We need to remove dead code for our variant-filter workaround for WebGPU to work
+    // This is especially relevant for removing the push constants that morphing uses when not disabled
+    spv::spirvbin_t remapper(0);
+    remapper.remap(*spirv, spv::spirvbin_base_t::DCE_ALL);
 
-    optimizeSpirv(optimizer, *spirv);
-
-    //After splitting the image samplers, we need to remap the bindings to separate them.
-    //TODO: This has issues, so use CreateResolveBindingConflictsPass instead. Mapping is less predictable but short term
-    rebindImageSamplerForWGSL(*spirv);
-
-    //Allow non-uniform derivitives due to our nested shaders. See https://github.com/gpuweb/gpuweb/issues/3479
-    const tint::spirv::reader::Options readerOpts{true};
+    //Currently no options we want to use
+    const tint::spirv::reader::Options readerOpts{};
     tint::wgsl::writer::Options writerOpts{};
 
     tint::Program tintRead = tint::spirv::reader::Read(*spirv, readerOpts);
 
     if (tintRead.Diagnostics().ContainsErrors()) {
-        //We know errors can potentially crop up, and want the ability to ignore them if needed for sample bringup
-#ifndef FILAMENT_WEBGPU_IGNORE_TNT_READ_ERRORS
-        slog.e << "Tint Reader Error: " << tintRead.Diagnostics().Str() << io::endl;
-        spv_context context = spvContextCreate(SPV_ENV_VULKAN_1_1_SPIRV_1_4);
-        spv_text text = nullptr;
-        spv_diagnostic diagnostic = nullptr;
-        spv_result_t result = spvBinaryToText(
-            context,
-            spirv->data(),
-            spirv->size(),
-            SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES | SPV_BINARY_TO_TEXT_OPTION_COLOR,
-            &text,
-            &diagnostic);
-        slog.e << "Beginning SpirV-output dump\n\n" << text->str << "\n\nEndSPIRV\n" << io::endl;
-        spvTextDestroy(text);
-        return false;
-#endif
+        //TODO remove this if block once combined image sampler conversion works.
+        if (tintRead.Diagnostics().Str().rfind("error: WGSL does not support combined image-samplers") != std::string::npos) {
+            slog.w << "This tint reader error is currently ignored during WebGPU bringup: " << tintRead.Diagnostics().Str() << io::endl;
+        }
+        else {
+            slog.e << "Tint Reader Error: " << tintRead.Diagnostics().Str() << io::endl;
+            return false;
+        }
     }
 
     tint::Result<tint::wgsl::writer::Output> wgslOut = tint::wgsl::writer::Generate(tintRead,writerOpts);
@@ -962,8 +887,10 @@ bool GLSLPostProcessor::fullOptimization(const TShader& tShader,
     return true;
 }
 
-std::shared_ptr<spvtools::Optimizer> GLSLPostProcessor::createEmptyOptimizer() {
+std::shared_ptr<spvtools::Optimizer> GLSLPostProcessor::createOptimizer(
+        MaterialBuilder::Optimization optimization, Config const& config) {
     auto optimizer = std::make_shared<spvtools::Optimizer>(SPV_ENV_UNIVERSAL_1_3);
+
     optimizer->SetMessageConsumer([](spv_message_level_t level,
             const char* source, const spv_position_t& position, const char* message) {
         if (!filterSpvOptimizerMessage(level)) {
@@ -972,12 +899,6 @@ std::shared_ptr<spvtools::Optimizer> GLSLPostProcessor::createEmptyOptimizer() {
         slog.e << stringifySpvOptimizerMessage(level, source, position, message)
                 << io::endl;
     });
-    return optimizer;
-}
-
-std::shared_ptr<spvtools::Optimizer> GLSLPostProcessor::createOptimizer(
-        MaterialBuilder::Optimization optimization, Config const& config) {
-    auto optimizer = createEmptyOptimizer();
 
     if (optimization == MaterialBuilder::Optimization::SIZE) {
         // When optimizing for size, we don't run the SPIR-V through any size optimization passes
@@ -1002,7 +923,7 @@ std::shared_ptr<spvtools::Optimizer> GLSLPostProcessor::createOptimizer(
     return optimizer;
 }
 
-void GLSLPostProcessor::optimizeSpirv(OptimizerPtr optimizer, SpirvBlob& spirv) {
+void GLSLPostProcessor::optimizeSpirv(OptimizerPtr optimizer, SpirvBlob& spirv) const {
     if (!optimizer->Run(spirv.data(), spirv.size(), &spirv)) {
         slog.e << "SPIR-V optimizer pass failed" << io::endl;
         return;
@@ -1056,7 +977,7 @@ void GLSLPostProcessor::registerPerformancePasses(Optimizer& optimizer, Config c
 
     RegisterPass(CreateWrapOpKillPass());
     RegisterPass(CreateDeadBranchElimPass());
-    RegisterPass(CreateMergeReturnPass(), MaterialBuilder::TargetApi::METAL | MaterialBuilder::TargetApi::WEBGPU);
+    RegisterPass(CreateMergeReturnPass(), MaterialBuilder::TargetApi::METAL);
     RegisterPass(CreateInlineExhaustivePass());
     RegisterPass(CreateAggressiveDCEPass());
     RegisterPass(CreatePrivateToLocalPass());

libs/filamat/src/GLSLPostProcessor.h

@@ -114,20 +114,14 @@ private:
      * Retrieve an optimizer instance tuned for the given optimization level and shader configuration.
      */
     using OptimizerPtr = std::shared_ptr<spvtools::Optimizer>;
-
     static OptimizerPtr createOptimizer(
             MaterialBuilder::Optimization optimization,
             Config const& config);
 
-    static OptimizerPtr createEmptyOptimizer();
-
     static void registerSizePasses(spvtools::Optimizer& optimizer, Config const& config);
-
     static void registerPerformancePasses(spvtools::Optimizer& optimizer, Config const& config);
 
-    static void optimizeSpirv(OptimizerPtr optimizer, SpirvBlob &spirv);
-
-    static void rebindImageSamplerForWGSL(std::vector<uint32_t>& spirv);
+    void optimizeSpirv(OptimizerPtr optimizer, SpirvBlob& spirv) const;
 
     void fixupClipDistance(SpirvBlob& spirv, GLSLPostProcessor::Config const& config) const;
 

libs/filamat/src/shaders/CodeGenerator.cpp

@@ -937,15 +937,6 @@ utils::io::sstream& CodeGenerator::generateSpecializationConstant(utils::io::sst
     std::string const constantString = std::visit(SpecializationConstantFormatter(), value);
 
     static const char* types[] = { "int", "float", "bool" };
-
-    // Spec constants aren't fully supported in Tint,
-    //  workaround until https://issues.chromium.org/issues/42250586 is resolved
-    if (mTargetApi == TargetApi::WEBGPU) {
-        out << "layout (constant_id = " << id << ") const "
-                << types[value.index()] << " " << name << "_hack = " << constantString << ";\n"
-                << types[value.index()] << " " << name << " = " << name << "_hack;\n";
-        return out;
-    }
     if (mTargetLanguage == MaterialBuilderBase::TargetLanguage::SPIRV) {
         out << "layout (constant_id = " << id << ") const "
             << types[value.index()] << " " << name << " = " << constantString << ";\n";

shaders/src/surface_getters.fs

@@ -129,14 +129,14 @@ bool isDoubleSided() {
 /**
  * Returns the cascade index for this fragment (between 0 and CONFIG_MAX_SHADOW_CASCADES - 1).
  */
-uint getShadowCascade() {
+int getShadowCascade() {
     highp float z = mulMat4x4Float3(getViewFromWorldMatrix(), getWorldPosition()).z;
     ivec4 greaterZ = ivec4(greaterThan(frameUniforms.cascadeSplits, vec4(z)));
-    uint cascadeCount = frameUniforms.cascades & 0xF;
+    int cascadeCount = frameUniforms.cascades & 0xF;
     return clamp(greaterZ.x + greaterZ.y + greaterZ.z + greaterZ.w, 0, cascadeCount - 1);
 }
 
-highp vec4 getCascadeLightSpacePosition(uint cascade) {
+highp vec4 getCascadeLightSpacePosition(int cascade) {
     // For the first cascade, return the interpolated light space position.
     // This branch will be coherent (mostly) for neighboring fragments, and it's worth avoiding
     // the matrix multiply inside computeLightSpacePosition.

shaders/src/surface_light_directional.fs

@@ -52,12 +52,12 @@ void evaluateDirectionalLight(const MaterialInputs material,
     if (light.NoL > 0.0) {
         float ssContactShadowOcclusion = 0.0;
 
-        uint cascade = getShadowCascade();
+        int cascade = getShadowCascade();
         bool cascadeHasVisibleShadows = bool(frameUniforms.cascades & ((1 << cascade) << 8));
         bool hasDirectionalShadows = bool(frameUniforms.directionalShadows & 1);
         if (hasDirectionalShadows && cascadeHasVisibleShadows) {
             highp vec4 shadowPosition = getShadowPosition(cascade);
-            visibility = shadow(true, sampler0_shadowMap, int(cascade), shadowPosition, 0.0);
+            visibility = shadow(true, sampler0_shadowMap, cascade, shadowPosition, 0.0);
 #if defined(MATERIAL_HAS_SHADOW_STRENGTH)
             applyShadowStrength(visibility, material.shadowStrength);
 #endif

shaders/src/surface_shading_unlit.fs

@@ -41,7 +41,7 @@ vec4 evaluateMaterial(const MaterialInputs material) {
 #if defined(VARIANT_HAS_DIRECTIONAL_LIGHTING)
 #if defined(VARIANT_HAS_SHADOWING)
     float visibility = 1.0;
-    uint cascade = getShadowCascade();
+    int cascade = getShadowCascade();
     bool cascadeHasVisibleShadows = bool(frameUniforms.cascades & ((1 << cascade) << 8));
     bool hasDirectionalShadows = bool(frameUniforms.directionalShadows & 1);
     if (hasDirectionalShadows && cascadeHasVisibleShadows) {

shaders/src/surface_shadowing.fs

@@ -485,7 +485,7 @@ float ShadowSample_VSM(const bool ELVSM, const highp sampler2DArray shadowMap,
 
 // get texture coordinate for directional and spot shadow maps
 #if defined(VARIANT_HAS_DIRECTIONAL_LIGHTING)
-highp vec4 getShadowPosition(const uint cascade) {
+highp vec4 getShadowPosition(const int cascade) {
     return getCascadeLightSpacePosition(cascade);
 }
 #endif

third_party/spirv-tools/Android.mk

@@ -172,13 +172,11 @@ SPVTOOLS_OPT_SRC_FILES := \
 		source/opt/remove_unused_interface_variables_pass.cpp \
 		source/opt/replace_desc_array_access_using_var_index.cpp \
 		source/opt/replace_invalid_opc.cpp \
-		source/opt/resolve_binding_conflicts_pass.cpp \
 		source/opt/scalar_analysis.cpp \
 		source/opt/scalar_analysis_simplification.cpp \
 		source/opt/scalar_replacement_pass.cpp \
 		source/opt/set_spec_constant_default_value_pass.cpp \
 		source/opt/simplification_pass.cpp \
-		source/opt/split_combined_image_sampler_pass.cpp \
 		source/opt/spread_volatile_semantics.cpp \
 		source/opt/ssa_rewrite_pass.cpp \
 		source/opt/strength_reduction_pass.cpp \

third_party/spirv-tools/BUILD.bazel

@@ -201,7 +201,6 @@ cc_library(
     deps = [
         ":spirv_tools_internal",
         "@spirv_headers//:spirv_common_headers",
-        "@spirv_headers//:spirv_c_headers",
     ],
 )
 

third_party/spirv-tools/BUILD.gn

@@ -771,8 +771,6 @@ static_library("spvtools_opt") {
     "source/opt/replace_desc_array_access_using_var_index.h",
     "source/opt/replace_invalid_opc.cpp",
     "source/opt/replace_invalid_opc.h",
-    "source/opt/resolve_binding_conflicts_pass.cpp",
-    "source/opt/resolve_binding_conflicts_pass.h",
     "source/opt/scalar_analysis.cpp",
     "source/opt/scalar_analysis.h",
     "source/opt/scalar_analysis_nodes.h",
@@ -783,8 +781,6 @@ static_library("spvtools_opt") {
     "source/opt/set_spec_constant_default_value_pass.h",
     "source/opt/simplification_pass.cpp",
     "source/opt/simplification_pass.h",
-    "source/opt/split_combined_image_sampler_pass.cpp",
-    "source/opt/split_combined_image_sampler_pass.h",
     "source/opt/spread_volatile_semantics.cpp",
     "source/opt/spread_volatile_semantics.h",
     "source/opt/ssa_rewrite_pass.cpp",
@@ -1386,7 +1382,6 @@ if (build_with_chromium && spvtools_build_executables) {
       "test/libspirv_macros_test.cpp",
       "test/name_mapper_test.cpp",
       "test/named_id_test.cpp",
-      "test/op_unknown_test.cpp",
       "test/opcode_make_test.cpp",
       "test/opcode_require_capabilities_test.cpp",
       "test/opcode_split_test.cpp",

third_party/spirv-tools/CHANGES

@@ -1,40 +1,5 @@
 Revision history for SPIRV-Tools
 
-v2025.1 2025-02-28
-  - General
-    - diff: Fix crash in OpString matching (#5988)
-    - Add SPV_AMDX_shader_enqueue version 2 support (#5838)
-    - add support for SPV_INTEL_subgroup_matrix_multiply_accumulate (#5928)
-    - update cmake_minimum_required to 3.22.1 (#5925)
-    - Add OpImageSampleFootprintNV to IsAllowedSampledImageOperand (#5914)
-    - assembler: ensure progress when seeking the version string (#5910)
-  - Optimizer
-    - opt: keep all OpSource instructions (#5901)
-    - [opt] Fix bug opt::InstructionBuilder::AddVariable (#6007)
-    - [OPT] Add SPV_KHR_ray_tracing to allow list (#5941)
-    - opt: keep all OpSource instructions (#5901)
-  - Validator
-    - spirv-val: Add AllowVulkan32BitBitwise option (#6001)
-    - Fix untyped pointer comparison validation (#6004)
-    - spirv-val: Update VUIDs for 308 header (#5990)
-    - spirv-val: fix env parsing for vk1.1spv1.4 (#5985)
-    - Add validation for SPV_NV_linear_swept_spheres. (#5975)
-    - Add validation SPV_NV_cluster_acceleration_structure. (#5974)
-    - Improve the instruction diagnostic for some access chain errors (#5978)
-    - Update physical storage buffer validation to match SPIR-V 1.6.5 (#5977)
-    - Validate SPV_NV_cooperative_vector (#5972)
-    - Fix layout checks with untyped pointers (#5970)
-    - spirv-val: Update mislabeled VUIDs (#5964)
-    - More explicit layout validation (#5958)
-    - spirv-val: Add VK_KHR_maintenance8 support (#5951)
-    - Add EXT_mesh_shader validation support (#5640)
-    - spirv-val: Remove OpenCL ivec3 req (#5940)
-    - spirv-val: Validate zero product workgroup size (#5407)
-    - Relax DebugLine validation (#5916)
-  - Linker
-    - linker: remove LinkOnceODR decorations when linking executables (#5979)
-    - fix: handle LinkOnceODR correctly (#5938)
-
 v2024.4 2024-12-04
   - General
     - Add FPEncoding operand type. (#5726)

third_party/spirv-tools/DEPS

@@ -3,18 +3,18 @@ use_relative_paths = True
 vars = {
   'github': 'https://github.com',
 
-  'abseil_revision': '9f5fc9d1e934571a1f713b5a00cd5f15db8c71ed',
+  'abseil_revision': '69b58f9227bf91a9315475579df15fbb7c5c612e',
 
-  'effcee_revision': '874b47102c57a8979c0f154cf8e0eab53c0a0502',
+  'effcee_revision': '12241cbc30f20730b656db7fd5a3fa36cd420843',
 
-  'googletest_revision': '3af834740f58ef56058e6f8a1be51f62bc3a6515',
+  'googletest_revision': 'e235eb34c6c4fed790ccdad4b16394301360dcd4',
 
   # Use protobufs before they gained the dependency on abseil
   'protobuf_revision': 'v21.12',
 
-  're2_revision': 'c84a140c93352cdabbfb547c531be34515b12228',
+  're2_revision': '6dcd83d60f7944926bfd308cc13979fc53dd69ca',
 
-  'spirv_headers_revision': '0e710677989b4326ac974fd80c5308191ed80965',
+  'spirv_headers_revision': 'e7294a8ebed84f8c5bd3686c68dbe12a4e65b644',
 }
 
 deps = {

third_party/spirv-tools/docs/syntax.md

@@ -215,50 +215,6 @@ Note that this has some interesting consequences, including:
   that named ID being output.  This may be valid SPIR-V, contrary to the
   presumed intention of the writer.
 
-## OpUnknown
-<a name="op-unknown"></a>
-
-HLSL has a feature that allows users to specify an exact SPIR-V type using [the
-`SpirvType` template](https://github.com/microsoft/hlsl-specs/blob/main/proposals/0011-inline-spirv.md#types).
-This feature allows the user to specify a type opcode that the compiler does
-not know. In this case, it will be unable to generate assembly using the
-correct mnemonic.
-
-In order to represent unknown opcodes in assembly format, the `OpUnknown`
-pseudo-instruction may be used. The syntax is:
-
-```
-OpUnknown(<enumerant>, <WordCount>) <operand 1> ...
-```
-
-`enumerant` is the opcode enumerant, and `WordCount` is the number of words in
-the instruction. These will be assembled into a single word representing the
-opcode. Operands will be parsed according to the alternate parsing mode
-described in [Arbitrary Integers](#op-unknown). Named enumerated values cannot
-be handled by this mode and must be represented using the arbitrary integer
-syntax.
-
-It must be used at the beginning of a new instruction, and if there is a result
-ID it must explicitly be passed in as an operand. This is because the physical
-layout of a SPIR-V instruction may include a result type operand before the
-result ID operand, but it depends on the opcode and cannot be inferred for an
-unknown operand.
-
-For example, a 32-bit signed integer type could be represented like this:
-
-```
-OpUnknown(21, 4) %int_t 32 1
-```
-
-An OpStore instruction could be represented as:
-
-```
-OpUnknown(62, 3) %9 %12
-```
-
-The enumerant and word count must be decimal integers.
-
-
 ## Notes
 
 * Some enumerants cannot be used by name, because the target instruction

third_party/spirv-tools/include/spirv-tools/libspirv.h

@@ -740,10 +740,6 @@ SPIRV_TOOLS_EXPORT void spvValidatorOptionsSetAllowLocalSizeId(
 SPIRV_TOOLS_EXPORT void spvValidatorOptionsSetAllowOffsetTextureOperand(
     spv_validator_options options, bool val);
 
-// Allow base operands of some bit operations to be non-32-bit wide.
-SPIRV_TOOLS_EXPORT void spvValidatorOptionsSetAllowVulkan32BitBitwise(
-    spv_validator_options options, bool val);
-
 // Whether friendly names should be used in validation error messages.
 SPIRV_TOOLS_EXPORT void spvValidatorOptionsSetFriendlyNames(
     spv_validator_options options, bool val);

third_party/spirv-tools/include/spirv-tools/libspirv.hpp

@@ -132,11 +132,6 @@ class SPIRV_TOOLS_EXPORT ValidatorOptions {
     spvValidatorOptionsSetAllowOffsetTextureOperand(options_, val);
   }
 
-  // Allow base operands of some bit operations to be non-32-bit wide.
-  void SetAllowVulkan32BitBitwise(bool val) {
-    spvValidatorOptionsSetAllowVulkan32BitBitwise(options_, val);
-  }
-
   // Records whether or not the validator should relax the rules on pointer
   // usage in logical addressing mode.
   //

third_party/spirv-tools/include/spirv-tools/optimizer.hpp

@@ -240,7 +240,7 @@ class SPIRV_TOOLS_EXPORT Optimizer {
 
  private:
   struct SPIRV_TOOLS_LOCAL Impl;  // Opaque struct for holding internal data.
-  std::unique_ptr<Impl> impl_;    // Unique pointer to internal data.
+  std::unique_ptr<Impl> impl_;  // Unique pointer to internal data.
 };
 
 // Creates a null pass.
@@ -655,7 +655,7 @@ Optimizer::PassToken CreateRedundancyEliminationPass();
 // element if those elements are accessed individually.  The parameter is a
 // limit on the number of members in the composite variable that the pass will
 // consider replacing.
-Optimizer::PassToken CreateScalarReplacementPass(uint32_t size_limit = 0);
+Optimizer::PassToken CreateScalarReplacementPass(uint32_t size_limit = 100);
 
 // Create a private to local pass.
 // This pass looks for variables declared in the private storage class that are
@@ -968,60 +968,6 @@ Optimizer::PassToken CreateInvocationInterlockPlacementPass();
 // Creates a pass to add/remove maximal reconvergence execution mode.
 // This pass either adds or removes maximal reconvergence from all entry points.
 Optimizer::PassToken CreateModifyMaximalReconvergencePass(bool add);
-
-// Creates a pass to split combined image+sampler variables and function
-// parameters into separate image and sampler parts. Binding numbers and
-// other decorations are copied.
-Optimizer::PassToken CreateSplitCombinedImageSamplerPass();
-
-// Creates a pass to remap bindings to avoid conflicts, assuming the module
-// is valid for Vulkan.  A conflict exits when an entry point uses two distinct
-// variables with the same descriptor set and binding.  Vulkan allows one kind
-// of conflict: when one varible is an image (or array of images), and the
-// other is a sampler (or an array of samplers).
-
-// Conflicts are eliminated by incrementing the binding number of the sampler
-// part, and then propagating that increment through variables with
-// higher-numbered bindings until no conflict remains. This handles the case
-// when multiple shaders may share the same resource variables; this can
-// introduce holes in binding slots.
-//
-// Here's an example where shaders Alpha, Beta, Gamma, Delta collectively use
-// resource variables %100, %101, %102, %103, %104 all with the same
-// DescriptorSet and with Bindings as in the following table:
-//
-// Before:
-//
-//   Binding:   0          1        2        3
-//   Alpha:    %100,%101
-//   Beta:     %100       %102
-//   Gamma:               %102     %103
-//   Delta:                        %103     %104
-//
-// The Alpha shader has a conflict where variables %100, %101 have the same
-// descriptor set and binding.  If %100 is a sampler resource variable, then
-// the conflict is resolved by incrementing the binding number on %100 from 0
-// to 1.  But this causes a new confict for shader Beta because it now uses
-// both %100 and %102 with binding number 1.  That conflict is resolved by
-// incrementing the binding number on its variable that originally appeared
-// second (i.e. %102), so %102 gets binding 2. This now produces a conflict
-// for Gamma between %102 and %103 using binding number 2. Since %103 originally
-// appeared second (in the view from Gamma), the algorithm bumps %103 to binding
-// number %103. Now Delta has a conflict between %103 and %104, resulting in
-// %104 getting the next binding number, 4.  The picture afterward is:
-//
-// After:
-//
-//   Binding:   0          1        2        3        4
-//   Alpha:    %101       %100
-//   Beta:                %100     %102
-//   Gamma:                        %102     %103
-//   Delta:                                 %103     %104
-//
-//
-// This pass assumes binding numbers are not applid via decoration groups
-// (OpDecorationGroup).
-Optimizer::PassToken CreateResolveBindingConflictsPass();
 }  // namespace spvtools
 
 #endif  // INCLUDE_SPIRV_TOOLS_OPTIMIZER_HPP_

third_party/spirv-tools/kokoro/check-format/build-docker.sh

@@ -1,26 +0,0 @@
-#!/bin/bash
-# Copyright (c) 2025 Google LLC
-#
-# 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.
-
-# Fail on any error.
-set -e
-
-# This is required to run any git command in the docker since owner will
-# have changed between the clone environment, and the docker container.
-# Marking the root of the repo as safe for ownership changes.
-git config --global --add safe.directory "$PWD"
-
-echo $(date): Check formatting...
-./utils/check_code_format.sh ${1:-main}
-echo $(date): check completed.

third_party/spirv-tools/kokoro/check-format/build.sh

@@ -1,5 +1,5 @@
 #!/bin/bash
-# Copyright (c) 2025 Google LLC
+# Copyright (c) 2018 Google LLC.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,16 +12,37 @@
 # 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.
+#
+# Android Build Script.
 
 # Fail on any error.
 set -e
+# Display commands being run.
+set -x
 
-SCRIPT_DIR="$( cd "$(dirname "${BASH_SOURCE[0]}")" >/dev/null 2>&1 && pwd )"
-SRC_ROOT="$( cd "${SCRIPT_DIR}/../.." >/dev/null 2>&1 && pwd )"
-TARGET_BRANCH="${KOKORO_GITHUB_PULL_REQUEST_TARGET_BRANCH-main}"
+BUILD_ROOT=$PWD
+SRC=$PWD/github/SPIRV-Tools
 
-docker run --rm -i \
-  --volume "${SRC_ROOT}:${SRC_ROOT}" \
-  --workdir "${SRC_ROOT}" \
-  "us-east4-docker.pkg.dev/shaderc-build/radial-docker/ubuntu-24.04-amd64/formatter" \
-  "${SCRIPT_DIR}/build-docker.sh" "${TARGET_BRANCH}"
+# This is required to run any git command in the docker since owner will
+# have changed between the clone environment, and the docker container.
+# Marking the root of the repo as safe for ownership changes.
+git config --global --add safe.directory $SRC
+
+# Get clang-format-5.0.0.
+# Once kokoro upgrades the Ubuntu VMs, we can use 'apt-get install clang-format'
+curl -L http://releases.llvm.org/5.0.0/clang+llvm-5.0.0-linux-x86_64-ubuntu14.04.tar.xz -o clang-llvm.tar.xz
+tar xf clang-llvm.tar.xz
+export PATH=$PWD/clang+llvm-5.0.0-linux-x86_64-ubuntu14.04/bin:$PATH
+
+cd $SRC
+git clone --depth=1 https://github.com/KhronosGroup/SPIRV-Headers external/spirv-headers
+git clone https://github.com/google/googletest          external/googletest
+cd external && cd googletest && git reset --hard 1fb1bb23bb8418dc73a5a9a82bbed31dc610fec7 && cd .. && cd ..
+git clone --depth=1 https://github.com/google/effcee              external/effcee
+git clone --depth=1 https://github.com/google/re2                 external/re2
+# The --fail flag causes the command to fail on HTTP error response codes, like 404.
+curl -L --fail https://raw.githubusercontent.com/llvm/llvm-project/main/clang/tools/clang-format/clang-format-diff.py -o utils/clang-format-diff.py
+
+echo $(date): Check formatting...
+./utils/check_code_format.sh;
+echo $(date): check completed.

third_party/spirv-tools/kokoro/scripts/linux/build.sh

@@ -52,7 +52,7 @@ docker run --rm -i \
   --env KOKORO_ARTIFACTS_DIR="${KOKORO_ARTIFACTS_DIR}" \
   --env BUILD_SHA="${BUILD_SHA}" \
   --entrypoint "${SCRIPT_DIR}/build-docker.sh" \
-  us-east4-docker.pkg.dev/shaderc-build/radial-docker/ubuntu-24.04-amd64/cpp-builder
+  "gcr.io/shaderc-build/radial-build:latest"
 RESULT=$?
 
 # This is important. If the permissions are not fixed, kokoro will fail

third_party/spirv-tools/source/diff/diff.cpp

@@ -67,9 +67,7 @@ void CompactIds(std::vector<uint32_t>& ids) {
   ids.resize(write_index);
 }
 
-// A mapping from ids in one module to ids in the other.
-//
-// Differ contains two of these, for src->dst and dst->src.
+// A mapping between src and dst ids.
 class IdMap {
  public:
   IdMap(size_t id_bound) { id_map_.resize(id_bound, 0); }
@@ -192,7 +190,6 @@ class SrcDstIdMap {
   IdMap dst_to_src_;
 };
 
-// Mappings from ids to instructions and metadata, for a single module's ids.
 struct IdInstructions {
   IdInstructions(const opt::Module* module)
       : inst_map_(module->IdBound(), nullptr),
@@ -201,10 +198,6 @@ struct IdInstructions {
         forward_pointer_map_(module->IdBound()) {
     // Map ids from all sections to instructions that define them.
     MapIdsToInstruction(module->ext_inst_imports());
-    MapIdsToInstruction(module->debugs1());
-    MapIdsToInstruction(module->debugs2());
-    MapIdsToInstruction(module->debugs3());
-    MapIdsToInstruction(module->ext_inst_debuginfo());
     MapIdsToInstruction(module->types_values());
     for (const opt::Function& function : *module) {
       function.ForEachInst(
@@ -328,8 +321,6 @@ class Differ {
   // Get various properties from an id.  These Helper functions are passed to
   // `GroupIds` and `GroupIdsAndMatch` below (as the `get_group` argument).
   uint32_t GroupIdsHelperGetTypeId(const IdInstructions& id_to, uint32_t id);
-  uint32_t GroupIdsHelperGetFunctionTypeId(const IdInstructions& id_to,
-                                           uint32_t id);
   spv::StorageClass GroupIdsHelperGetTypePointerStorageClass(
       const IdInstructions& id_to, uint32_t id);
   spv::Op GroupIdsHelperGetTypePointerTypeOp(const IdInstructions& id_to,
@@ -892,17 +883,6 @@ uint32_t Differ::GroupIdsHelperGetTypeId(const IdInstructions& id_to,
   return GetInst(id_to, id)->type_id();
 }
 
-// Return an `OpFunction` instruction's full `OpTypeFunction` type,
-// which includes parameter types.
-//
-// `GroupIdsHelperGetTypeId` applied to an `OpFunction` only gets the
-// function's return type, so this is a slightly more precise way to
-// match up functions by signature.
-uint32_t Differ::GroupIdsHelperGetFunctionTypeId(const IdInstructions& id_to,
-                                                 uint32_t id) {
-  return GetInst(id_to, id)->GetSingleWordOperand(3);
-}
-
 spv::StorageClass Differ::GroupIdsHelperGetTypePointerStorageClass(
     const IdInstructions& id_to, uint32_t id) {
   const opt::Instruction* inst = GetInst(id_to, id);
@@ -922,24 +902,6 @@ spv::Op Differ::GroupIdsHelperGetTypePointerTypeOp(const IdInstructions& id_to,
   return type_inst->opcode();
 }
 
-// Group unmatched ids in `ids` according to some characteristic,
-// determined by `get_group`.
-//
-// Using `get_group` to compute some sort of key for each id, set
-// `groups` to map each key to all the ids that have that key.
-//
-// For example, to group ids by name, pass `Differ::GetName` as
-// `get_group`. This will fill `groups` with a map from each name to
-// all the ids with that name.
-//
-// Under the assumption that we're trying to establish new pairings,
-// ids that are already paired are omitted from `groups`.
-//
-// The `is_src` parameter indicates whether `ids` are drawn from the
-// source module or the destination module.
-//
-// The template parameter `T` is the key type, like `std::string` or
-// `uint32_t`.
 template <typename T>
 void Differ::GroupIds(const IdGroup& ids, bool is_src,
                       std::map<T, IdGroup>* groups,
@@ -962,10 +924,6 @@ void Differ::GroupIds(const IdGroup& ids, bool is_src,
   }
 }
 
-// Group `src_ids` and `dst_ids` according to `get_group`, and then use
-// `match_group` to pair up ids in corresponding groups.
-//
-// Don't try to pair ids in groups whose key is `invalid_group_key`.
 template <typename T>
 void Differ::GroupIdsAndMatch(
     const IdGroup& src_ids, const IdGroup& dst_ids, T invalid_group_key,
@@ -2525,7 +2483,7 @@ void Differ::MatchFunctions() {
 
         // If there are multiple functions with the same name, group them by
         // type, and match only if the types match (and are unique).
-        GroupIdsAndMatchByMappedId(src_group, dst_group,
+        GroupIdsAndMatch<uint32_t>(src_group, dst_group, 0,
                                    &Differ::GroupIdsHelperGetTypeId,
                                    [this](const IdGroup& src_group_by_type_id,
                                           const IdGroup& dst_group_by_type_id) {
@@ -2568,19 +2526,9 @@ void Differ::MatchFunctions() {
                              dst_match_result, 0);
   }
 
-  // Best effort match functions with matching return and argument types.
-  GroupIdsAndMatchByMappedId(
-      src_func_ids, dst_func_ids, &Differ::GroupIdsHelperGetFunctionTypeId,
-      [this](const IdGroup& src_group_by_func_type_id,
-             const IdGroup& dst_group_by_func_type_id) {
-        BestEffortMatchFunctions(src_group_by_func_type_id,
-                                 dst_group_by_func_type_id, src_func_insts_,
-                                 dst_func_insts_);
-      });
-
-  // Best effort match functions with matching return types.
-  GroupIdsAndMatchByMappedId(
-      src_func_ids, dst_func_ids, &Differ::GroupIdsHelperGetTypeId,
+  // Best effort match functions with matching type.
+  GroupIdsAndMatch<uint32_t>(
+      src_func_ids, dst_func_ids, 0, &Differ::GroupIdsHelperGetTypeId,
       [this](const IdGroup& src_group_by_type_id,
              const IdGroup& dst_group_by_type_id) {
         BestEffortMatchFunctions(src_group_by_type_id, dst_group_by_type_id,

third_party/spirv-tools/source/link/linker.cpp

@@ -676,10 +676,8 @@ spv_result_t RemoveLinkageSpecificInstructions(
       if (inst->opcode() == spv::Op::OpDecorate &&
           spv::Decoration(inst->GetSingleWordOperand(1u)) ==
               spv::Decoration::LinkageAttributes &&
-          (spv::LinkageType(inst->GetSingleWordOperand(3u)) ==
-               spv::LinkageType::Export ||
-           spv::LinkageType(inst->GetSingleWordOperand(3u)) ==
-               spv::LinkageType::LinkOnceODR)) {
+          spv::LinkageType(inst->GetSingleWordOperand(3u)) ==
+              spv::LinkageType::Export) {
         linked_context->KillInst(&*inst);
       }
     }

third_party/spirv-tools/source/opt/CMakeLists.txt

@@ -109,13 +109,11 @@ set(SPIRV_TOOLS_OPT_SOURCES
   remove_unused_interface_variables_pass.h
   replace_desc_array_access_using_var_index.h
   replace_invalid_opc.h
-  resolve_binding_conflicts_pass.h
   scalar_analysis.h
   scalar_analysis_nodes.h
   scalar_replacement_pass.h
   set_spec_constant_default_value_pass.h
   simplification_pass.h
-  split_combined_image_sampler_pass.h
   spread_volatile_semantics.h
   ssa_rewrite_pass.h
   strength_reduction_pass.h
@@ -227,13 +225,11 @@ set(SPIRV_TOOLS_OPT_SOURCES
   remove_unused_interface_variables_pass.cpp
   replace_desc_array_access_using_var_index.cpp
   replace_invalid_opc.cpp
-  resolve_binding_conflicts_pass.cpp
   scalar_analysis.cpp
   scalar_analysis_simplification.cpp
   scalar_replacement_pass.cpp
   set_spec_constant_default_value_pass.cpp
   simplification_pass.cpp
-  split_combined_image_sampler_pass.cpp
   spread_volatile_semantics.cpp
   ssa_rewrite_pass.cpp
   strength_reduction_pass.cpp

third_party/spirv-tools/source/opt/copy_prop_arrays.cpp

@@ -276,7 +276,6 @@ CopyPropagateArrays::GetSourceObjectIfAny(uint32_t result) {
     case spv::Op::OpCompositeConstruct:
       return BuildMemoryObjectFromCompositeConstruct(result_inst);
     case spv::Op::OpCopyObject:
-    case spv::Op::OpCopyLogical:
       return GetSourceObjectIfAny(result_inst->GetSingleWordInOperand(0));
     case spv::Op::OpCompositeInsert:
       return BuildMemoryObjectFromInsert(result_inst);

third_party/spirv-tools/source/opt/fold.cpp

@@ -50,7 +50,7 @@ uint32_t InstructionFolder::UnaryOperate(spv::Op opcode,
       if (s_operand == std::numeric_limits<int32_t>::min()) {
         return s_operand;
       }
-      return static_cast<uint32_t>(-s_operand);
+      return -s_operand;
     }
     case spv::Op::OpNot:
       return ~operand;

third_party/spirv-tools/source/opt/folding_rules.cpp

@@ -2454,31 +2454,6 @@ FoldingRule RedundantFDiv() {
     FloatConstantKind kind0 = getFloatConstantKind(constants[0]);
     FloatConstantKind kind1 = getFloatConstantKind(constants[1]);
 
-    if (kind0 == FloatConstantKind::Zero || kind1 == FloatConstantKind::One) {
-      inst->SetOpcode(spv::Op::OpCopyObject);
-      inst->SetInOperands(
-          {{SPV_OPERAND_TYPE_ID, {inst->GetSingleWordInOperand(0)}}});
-      return true;
-    }
-
-    return false;
-  };
-}
-
-FoldingRule RedundantFMod() {
-  return [](IRContext* context, Instruction* inst,
-            const std::vector<const analysis::Constant*>& constants) {
-    assert(inst->opcode() == spv::Op::OpFMod &&
-           "Wrong opcode.  Should be OpFMod.");
-    assert(constants.size() == 2);
-
-    if (!inst->IsFloatingPointFoldingAllowed()) {
-      return false;
-    }
-
-    FloatConstantKind kind0 = getFloatConstantKind(constants[0]);
-    FloatConstantKind kind1 = getFloatConstantKind(constants[1]);
-
     if (kind0 == FloatConstantKind::Zero) {
       inst->SetOpcode(spv::Op::OpCopyObject);
       inst->SetInOperands(
@@ -2487,15 +2462,9 @@ FoldingRule RedundantFMod() {
     }
 
     if (kind1 == FloatConstantKind::One) {
-      auto type = context->get_type_mgr()->GetType(inst->type_id());
-      std::vector<uint32_t> zero_words;
-      zero_words.resize(ElementWidth(type) / 32);
-      auto const_mgr = context->get_constant_mgr();
-      auto zero = const_mgr->GetConstant(type, std::move(zero_words));
-      auto zero_id = const_mgr->GetDefiningInstruction(zero)->result_id();
-
       inst->SetOpcode(spv::Op::OpCopyObject);
-      inst->SetInOperands({{SPV_OPERAND_TYPE_ID, {zero_id}}});
+      inst->SetInOperands(
+          {{SPV_OPERAND_TYPE_ID, {inst->GetSingleWordInOperand(0)}}});
       return true;
     }
 
@@ -2538,18 +2507,24 @@ FoldingRule RedundantFMix() {
   };
 }
 
-// Returns a folding rule that folds the instruction to operand |foldToArg|
-// (0 or 1) if operand |arg| (0 or 1) is a zero constant.
-FoldingRule RedundantBinaryOpWithZeroOperand(uint32_t arg, uint32_t foldToArg) {
-  return [arg, foldToArg](
-             IRContext* context, Instruction* inst,
-             const std::vector<const analysis::Constant*>& constants) {
-    assert(constants.size() == 2);
+// This rule handles addition of zero for integers.
+FoldingRule RedundantIAdd() {
+  return [](IRContext* context, Instruction* inst,
+            const std::vector<const analysis::Constant*>& constants) {
+    assert(inst->opcode() == spv::Op::OpIAdd &&
+           "Wrong opcode. Should be OpIAdd.");
 
-    if (constants[arg] && constants[arg]->IsZero()) {
-      auto operand = inst->GetSingleWordInOperand(foldToArg);
-      auto operand_type = constants[arg]->type();
+    uint32_t operand = std::numeric_limits<uint32_t>::max();
+    const analysis::Type* operand_type = nullptr;
+    if (constants[0] && constants[0]->IsZero()) {
+      operand = inst->GetSingleWordInOperand(1);
+      operand_type = constants[0]->type();
+    } else if (constants[1] && constants[1]->IsZero()) {
+      operand = inst->GetSingleWordInOperand(0);
+      operand_type = constants[1]->type();
+    }
 
+    if (operand != std::numeric_limits<uint32_t>::max()) {
       const analysis::Type* inst_type =
           context->get_type_mgr()->GetType(inst->type_id());
       if (inst_type->IsSame(operand_type)) {
@@ -2564,117 +2539,6 @@ FoldingRule RedundantBinaryOpWithZeroOperand(uint32_t arg, uint32_t foldToArg) {
   };
 }
 
-// This rule handles any of RedundantBinaryRhs0Ops with a 0 or vector 0 on the
-// right-hand side (a | 0 => a).
-static const constexpr spv::Op RedundantBinaryRhs0Ops[] = {
-    spv::Op::OpBitwiseOr,
-    spv::Op::OpBitwiseXor,
-    spv::Op::OpShiftRightLogical,
-    spv::Op::OpShiftRightArithmetic,
-    spv::Op::OpShiftLeftLogical,
-    spv::Op::OpIAdd,
-    spv::Op::OpISub};
-FoldingRule RedundantBinaryRhs0(spv::Op op) {
-  assert(std::find(std::begin(RedundantBinaryRhs0Ops),
-                   std::end(RedundantBinaryRhs0Ops),
-                   op) != std::end(RedundantBinaryRhs0Ops) &&
-         "Wrong opcode.");
-  (void)op;
-  return RedundantBinaryOpWithZeroOperand(1, 0);
-}
-
-// This rule handles any of RedundantBinaryLhs0Ops with a 0 or vector 0 on the
-// left-hand side (0 | a => a).
-static const constexpr spv::Op RedundantBinaryLhs0Ops[] = {
-    spv::Op::OpBitwiseOr, spv::Op::OpBitwiseXor, spv::Op::OpIAdd};
-FoldingRule RedundantBinaryLhs0(spv::Op op) {
-  assert(std::find(std::begin(RedundantBinaryLhs0Ops),
-                   std::end(RedundantBinaryLhs0Ops),
-                   op) != std::end(RedundantBinaryLhs0Ops) &&
-         "Wrong opcode.");
-  (void)op;
-  return RedundantBinaryOpWithZeroOperand(0, 1);
-}
-
-// This rule handles shifts and divisions of 0 or vector 0 by any amount
-// (0 >> a => 0).
-static const constexpr spv::Op RedundantBinaryLhs0To0Ops[] = {
-    spv::Op::OpShiftRightLogical,
-    spv::Op::OpShiftRightArithmetic,
-    spv::Op::OpShiftLeftLogical,
-    spv::Op::OpSDiv,
-    spv::Op::OpUDiv,
-    spv::Op::OpSMod,
-    spv::Op::OpUMod};
-FoldingRule RedundantBinaryLhs0To0(spv::Op op) {
-  assert(std::find(std::begin(RedundantBinaryLhs0To0Ops),
-                   std::end(RedundantBinaryLhs0To0Ops),
-                   op) != std::end(RedundantBinaryLhs0To0Ops) &&
-         "Wrong opcode.");
-  (void)op;
-  return RedundantBinaryOpWithZeroOperand(0, 0);
-}
-
-// Returns true if all elements in |c| are 1.
-bool IsAllInt1(const analysis::Constant* c) {
-  if (auto composite = c->AsCompositeConstant()) {
-    auto& components = composite->GetComponents();
-    return std::all_of(std::begin(components), std::end(components), IsAllInt1);
-  } else if (c->AsIntConstant()) {
-    return c->GetSignExtendedValue() == 1;
-  }
-
-  return false;
-}
-
-// This rule handles divisions by 1 or vector 1 (a / 1 => a).
-FoldingRule RedundantSUDiv() {
-  return [](IRContext* context, Instruction* inst,
-            const std::vector<const analysis::Constant*>& constants) {
-    assert(constants.size() == 2);
-    assert((inst->opcode() == spv::Op::OpUDiv ||
-            inst->opcode() == spv::Op::OpSDiv) &&
-           "Wrong opcode.");
-
-    if (constants[1] && IsAllInt1(constants[1])) {
-      auto operand = inst->GetSingleWordInOperand(0);
-      auto operand_type = constants[1]->type();
-
-      const analysis::Type* inst_type =
-          context->get_type_mgr()->GetType(inst->type_id());
-      if (inst_type->IsSame(operand_type)) {
-        inst->SetOpcode(spv::Op::OpCopyObject);
-      } else {
-        inst->SetOpcode(spv::Op::OpBitcast);
-      }
-      inst->SetInOperands({{SPV_OPERAND_TYPE_ID, {operand}}});
-      return true;
-    }
-    return false;
-  };
-}
-
-// This rule handles modulo from division by 1 or vector 1 (a % 1 => 0).
-FoldingRule RedundantSUMod() {
-  return [](IRContext* context, Instruction* inst,
-            const std::vector<const analysis::Constant*>& constants) {
-    assert(constants.size() == 2);
-    assert((inst->opcode() == spv::Op::OpUMod ||
-            inst->opcode() == spv::Op::OpSMod) &&
-           "Wrong opcode.");
-
-    if (constants[1] && IsAllInt1(constants[1])) {
-      auto type = context->get_type_mgr()->GetType(inst->type_id());
-      auto zero_id = context->get_constant_mgr()->GetNullConstId(type);
-
-      inst->SetOpcode(spv::Op::OpCopyObject);
-      inst->SetInOperands({{SPV_OPERAND_TYPE_ID, {zero_id}}});
-      return true;
-    }
-    return false;
-  };
-}
-
 // This rule look for a dot with a constant vector containing a single 1 and
 // the rest 0s.  This is the same as doing an extract.
 FoldingRule DotProductDoingExtract() {
@@ -3012,17 +2876,6 @@ void FoldingRules::AddFoldingRules() {
   // Note that the order in which rules are added to the list matters. If a rule
   // applies to the instruction, the rest of the rules will not be attempted.
   // Take that into consideration.
-  for (auto op : RedundantBinaryRhs0Ops)
-    rules_[op].push_back(RedundantBinaryRhs0(op));
-  for (auto op : RedundantBinaryLhs0Ops)
-    rules_[op].push_back(RedundantBinaryLhs0(op));
-  for (auto op : RedundantBinaryLhs0To0Ops)
-    rules_[op].push_back(RedundantBinaryLhs0To0(op));
-  rules_[spv::Op::OpSDiv].push_back(RedundantSUDiv());
-  rules_[spv::Op::OpUDiv].push_back(RedundantSUDiv());
-  rules_[spv::Op::OpSMod].push_back(RedundantSUMod());
-  rules_[spv::Op::OpUMod].push_back(RedundantSUMod());
-
   rules_[spv::Op::OpBitcast].push_back(BitCastScalarOrVector());
 
   rules_[spv::Op::OpCompositeConstruct].push_back(
@@ -3054,8 +2907,6 @@ void FoldingRules::AddFoldingRules() {
   rules_[spv::Op::OpFDiv].push_back(MergeDivMulArithmetic());
   rules_[spv::Op::OpFDiv].push_back(MergeDivNegateArithmetic());
 
-  rules_[spv::Op::OpFMod].push_back(RedundantFMod());
-
   rules_[spv::Op::OpFMul].push_back(RedundantFMul());
   rules_[spv::Op::OpFMul].push_back(MergeMulMulArithmetic());
   rules_[spv::Op::OpFMul].push_back(MergeMulDivArithmetic());
@@ -3070,6 +2921,7 @@ void FoldingRules::AddFoldingRules() {
   rules_[spv::Op::OpFSub].push_back(MergeSubAddArithmetic());
   rules_[spv::Op::OpFSub].push_back(MergeSubSubArithmetic());
 
+  rules_[spv::Op::OpIAdd].push_back(RedundantIAdd());
   rules_[spv::Op::OpIAdd].push_back(MergeAddNegateArithmetic());
   rules_[spv::Op::OpIAdd].push_back(MergeAddAddArithmetic());
   rules_[spv::Op::OpIAdd].push_back(MergeAddSubArithmetic());

third_party/spirv-tools/source/opt/function.h

@@ -17,7 +17,6 @@
 
 #include <algorithm>
 #include <functional>
-#include <iterator>
 #include <memory>
 #include <string>
 #include <unordered_set>
@@ -40,7 +39,6 @@ class Function {
  public:
   using iterator = UptrVectorIterator<BasicBlock>;
   using const_iterator = UptrVectorIterator<BasicBlock, true>;
-  using ParamList = std::vector<std::unique_ptr<Instruction>>;
 
   // Creates a function instance declared by the given OpFunction instruction
   // |def_inst|.
@@ -79,23 +77,6 @@ class Function {
   // Does nothing if the function doesn't have such a parameter.
   inline void RemoveParameter(uint32_t id);
 
-  // Rewrites the function parameters by calling a replacer callback.
-  // The replacer takes two parameters: an expiring unique pointer to a current
-  // instruction, and a back-inserter into a new list of unique pointers to
-  // instructions.  The replacer is called for each current parameter, in order.
-  // Not valid to call while also iterating through the parameter list, e.g.
-  // within the ForEachParam method.
-  using RewriteParamFn = std::function<void(
-      std::unique_ptr<Instruction>&&, std::back_insert_iterator<ParamList>&)>;
-  void RewriteParams(RewriteParamFn& replacer) {
-    ParamList new_params;
-    auto appender = std::back_inserter(new_params);
-    for (auto& param : params_) {
-      replacer(std::move(param), appender);
-    }
-    params_ = std::move(new_params);
-  }
-
   // Saves the given function end instruction.
   inline void SetFunctionEnd(std::unique_ptr<Instruction> end_inst);
 
@@ -216,7 +197,7 @@ class Function {
   // The OpFunction instruction that begins the definition of this function.
   std::unique_ptr<Instruction> def_inst_;
   // All parameters to this function.
-  ParamList params_;
+  std::vector<std::unique_ptr<Instruction>> params_;
   // All debug instructions in this function's header.
   InstructionList debug_insts_in_header_;
   // All basic blocks inside this function in specification order

third_party/spirv-tools/source/opt/inline_exhaustive_pass.cpp

@@ -55,11 +55,6 @@ Pass::Status InlineExhaustivePass::InlineExhaustive(Function* func) {
       }
     }
   }
-
-  if (modified) {
-    FixDebugDeclares(func);
-  }
-
   return (modified ? Status::SuccessWithChange : Status::SuccessWithoutChange);
 }
 

third_party/spirv-tools/source/opt/inline_pass.cpp

@@ -30,8 +30,6 @@ namespace {
 constexpr int kSpvFunctionCallFunctionId = 2;
 constexpr int kSpvFunctionCallArgumentId = 3;
 constexpr int kSpvReturnValueId = 0;
-constexpr int kSpvDebugDeclareVarInIdx = 3;
-constexpr int kSpvAccessChainBaseInIdx = 0;
 }  // namespace
 
 uint32_t InlinePass::AddPointerToType(uint32_t type_id,
@@ -860,68 +858,5 @@ void InlinePass::InitializeInline() {
 
 InlinePass::InlinePass() {}
 
-void InlinePass::FixDebugDeclares(Function* func) {
-  std::map<uint32_t, Instruction*> access_chains;
-  std::vector<Instruction*> debug_declare_insts;
-
-  func->ForEachInst([&access_chains, &debug_declare_insts](Instruction* inst) {
-    if (inst->opcode() == spv::Op::OpAccessChain) {
-      access_chains[inst->result_id()] = inst;
-    }
-    if (inst->GetCommonDebugOpcode() == CommonDebugInfoDebugDeclare) {
-      debug_declare_insts.push_back(inst);
-    }
-  });
-
-  for (auto& inst : debug_declare_insts) {
-    FixDebugDeclare(inst, access_chains);
-  }
-}
-
-void InlinePass::FixDebugDeclare(
-    Instruction* dbg_declare_inst,
-    const std::map<uint32_t, Instruction*>& access_chains) {
-  do {
-    uint32_t var_id =
-        dbg_declare_inst->GetSingleWordInOperand(kSpvDebugDeclareVarInIdx);
-
-    // The def-use chains are not kept up to date while inlining, so we need to
-    // get the variable by traversing the functions.
-    auto it = access_chains.find(var_id);
-    if (it == access_chains.end()) {
-      return;
-    }
-    Instruction* access_chain = it->second;
-
-    // If the variable id in the debug declare is an access chain, it is
-    // invalid. it needs to be fixed up. The debug declare will be updated so
-    // that its Var operand becomes the base of the access chain. The indexes of
-    // the access chain are prepended before the indexes of the debug declare.
-
-    std::vector<Operand> operands;
-    for (int i = 0; i < kSpvDebugDeclareVarInIdx; i++) {
-      operands.push_back(dbg_declare_inst->GetInOperand(i));
-    }
-
-    uint32_t access_chain_base =
-        access_chain->GetSingleWordInOperand(kSpvAccessChainBaseInIdx);
-    operands.push_back(Operand(SPV_OPERAND_TYPE_ID, {access_chain_base}));
-    operands.push_back(
-        dbg_declare_inst->GetInOperand(kSpvDebugDeclareVarInIdx + 1));
-
-    for (uint32_t i = kSpvAccessChainBaseInIdx + 1;
-         i < access_chain->NumInOperands(); ++i) {
-      operands.push_back(access_chain->GetInOperand(i));
-    }
-
-    for (uint32_t i = kSpvDebugDeclareVarInIdx + 2;
-         i < dbg_declare_inst->NumInOperands(); ++i) {
-      operands.push_back(dbg_declare_inst->GetInOperand(i));
-    }
-
-    dbg_declare_inst->SetInOperands(std::move(operands));
-  } while (true);
-}
-
 }  // namespace opt
 }  // namespace spvtools

third_party/spirv-tools/source/opt/inline_pass.h

@@ -150,12 +150,6 @@ class InlinePass : public Pass {
   // Initialize state for optimization of |module|
   void InitializeInline();
 
-  // Fixes invalid debug declare functions in `func` that were caused by
-  // inlining. This function cannot be called while in the middle of inlining
-  // because it needs to be able to find the instructions that define an
-  // id.
-  void FixDebugDeclares(Function* func);
-
   // Map from function's result id to function.
   std::unordered_map<uint32_t, Function*> id2function_;
 
@@ -247,11 +241,6 @@ class InlinePass : public Pass {
   // structural dominance.
   void UpdateSingleBlockLoopContinueTarget(
       uint32_t new_id, std::vector<std::unique_ptr<BasicBlock>>* new_blocks);
-
-  // Replaces the `var` operand of `dbg_declare_inst` and updates the indexes
-  // accordingly, if it is the id of an access chain in `access_chains`.
-  void FixDebugDeclare(Instruction* dbg_declare_inst,
-                       const std::map<uint32_t, Instruction*>& access_chains);
 };
 
 }  // namespace opt

third_party/spirv-tools/source/opt/ir_builder.h

@@ -15,7 +15,6 @@
 #ifndef SOURCE_OPT_IR_BUILDER_H_
 #define SOURCE_OPT_IR_BUILDER_H_
 
-#include <cassert>
 #include <limits>
 #include <memory>
 #include <utility>
@@ -481,11 +480,8 @@ class InstructionBuilder {
     return AddInstruction(std::move(select));
   }
 
-  Instruction* AddOpcodeAccessChain(spv::Op opcode, uint32_t type_id,
-                                    uint32_t base_ptr_id,
-                                    const std::vector<uint32_t>& ids) {
-    assert(opcode == spv::Op::OpAccessChain ||
-           opcode == spv::Op::OpInBoundsAccessChain);
+  Instruction* AddAccessChain(uint32_t type_id, uint32_t base_ptr_id,
+                              std::vector<uint32_t> ids) {
     std::vector<Operand> operands;
     operands.push_back({SPV_OPERAND_TYPE_ID, {base_ptr_id}});
 
@@ -494,22 +490,12 @@ class InstructionBuilder {
     }
 
     // TODO(1841): Handle id overflow.
-    std::unique_ptr<Instruction> new_inst(new Instruction(
-        GetContext(), opcode, type_id, GetContext()->TakeNextId(), operands));
+    std::unique_ptr<Instruction> new_inst(
+        new Instruction(GetContext(), spv::Op::OpAccessChain, type_id,
+                        GetContext()->TakeNextId(), operands));
     return AddInstruction(std::move(new_inst));
   }
 
-  Instruction* AddAccessChain(uint32_t type_id, uint32_t base_ptr_id,
-                              const std::vector<uint32_t>& ids) {
-    return AddOpcodeAccessChain(spv::Op::OpAccessChain, type_id, base_ptr_id,
-                                ids);
-  }
-  Instruction* AddInBoundsAccessChain(uint32_t type_id, uint32_t base_ptr_id,
-                                      const std::vector<uint32_t>& ids) {
-    return AddOpcodeAccessChain(spv::Op::OpInBoundsAccessChain, type_id,
-                                base_ptr_id, ids);
-  }
-
   Instruction* AddLoad(uint32_t type_id, uint32_t base_ptr_id,
                        uint32_t alignment = 0) {
     std::vector<Operand> operands;
@@ -528,19 +514,9 @@ class InstructionBuilder {
     return AddInstruction(std::move(new_inst));
   }
 
-  Instruction* AddCopyObject(uint32_t type_id, uint32_t value_id) {
-    std::vector<Operand> operands{{SPV_OPERAND_TYPE_ID, {value_id}}};
-
-    // TODO(1841): Handle id overflow.
-    std::unique_ptr<Instruction> new_inst(
-        new Instruction(GetContext(), spv::Op::OpCopyObject, type_id,
-                        GetContext()->TakeNextId(), operands));
-    return AddInstruction(std::move(new_inst));
-  }
-
   Instruction* AddVariable(uint32_t type_id, uint32_t storage_class) {
     std::vector<Operand> operands;
-    operands.push_back({SPV_OPERAND_TYPE_STORAGE_CLASS, {storage_class}});
+    operands.push_back({SPV_OPERAND_TYPE_ID, {storage_class}});
     std::unique_ptr<Instruction> new_inst(
         new Instruction(GetContext(), spv::Op::OpVariable, type_id,
                         GetContext()->TakeNextId(), operands));
@@ -596,26 +572,6 @@ class InstructionBuilder {
     return AddInstruction(std::move(new_inst));
   }
 
-  Instruction* AddDecoration(uint32_t target_id, spv::Decoration d,
-                             const std::vector<uint32_t>& literals) {
-    std::vector<Operand> operands;
-    operands.push_back({SPV_OPERAND_TYPE_ID, {target_id}});
-    operands.push_back({SPV_OPERAND_TYPE_DECORATION, {uint32_t(d)}});
-    for (uint32_t literal : literals) {
-      operands.push_back({SPV_OPERAND_TYPE_LITERAL_INTEGER, {literal}});
-    }
-
-    std::unique_ptr<Instruction> new_inst(
-        new Instruction(GetContext(), spv::Op::OpDecorate, 0, 0, operands));
-    // Decorations are annotation instructions.  Add it via the IR context,
-    // so the decoration manager will be updated.
-    // Decorations don't belong to basic blocks, so there is no need
-    // to update the instruction to block mapping.
-    Instruction* result = new_inst.get();
-    GetContext()->AddAnnotationInst(std::move(new_inst));
-    return result;
-  }
-
   Instruction* AddNaryExtendedInstruction(
       uint32_t result_type, uint32_t set, uint32_t instruction,
       const std::vector<uint32_t>& ext_operands) {
@@ -637,23 +593,6 @@ class InstructionBuilder {
     return AddInstruction(std::move(new_inst));
   }
 
-  Instruction* AddSampledImage(uint32_t sampled_image_type_id,
-                               uint32_t image_id, uint32_t sampler_id) {
-    std::vector<Operand> operands;
-    operands.push_back({SPV_OPERAND_TYPE_ID, {image_id}});
-    operands.push_back({SPV_OPERAND_TYPE_ID, {sampler_id}});
-
-    uint32_t result_id = GetContext()->TakeNextId();
-    if (result_id == 0) {
-      return nullptr;
-    }
-
-    std::unique_ptr<Instruction> new_inst(
-        new Instruction(GetContext(), spv::Op::OpSampledImage,
-                        sampled_image_type_id, result_id, operands));
-    return AddInstruction(std::move(new_inst));
-  }
-
   // Inserts the new instruction before the insertion point.
   Instruction* AddInstruction(std::unique_ptr<Instruction>&& insn) {
     Instruction* insn_ptr = &*insert_before_.InsertBefore(std::move(insn));

third_party/spirv-tools/source/opt/ir_context.cpp

@@ -564,7 +564,6 @@ void IRContext::AddCombinatorsForCapability(uint32_t capability) {
          (uint32_t)spv::Op::OpCompositeConstruct,
          (uint32_t)spv::Op::OpCompositeExtract,
          (uint32_t)spv::Op::OpCompositeInsert,
-         (uint32_t)spv::Op::OpCopyLogical,
          (uint32_t)spv::Op::OpCopyObject,
          (uint32_t)spv::Op::OpTranspose,
          (uint32_t)spv::Op::OpSampledImage,

third_party/spirv-tools/source/opt/optimizer.cpp

@@ -189,7 +189,7 @@ Optimizer& Optimizer::RegisterPerformancePasses(bool preserve_interface) {
       .RegisterPass(CreateLocalSingleBlockLoadStoreElimPass())
       .RegisterPass(CreateLocalSingleStoreElimPass())
       .RegisterPass(CreateAggressiveDCEPass(preserve_interface))
-      .RegisterPass(CreateScalarReplacementPass(0))
+      .RegisterPass(CreateScalarReplacementPass())
       .RegisterPass(CreateLocalAccessChainConvertPass())
       .RegisterPass(CreateLocalSingleBlockLoadStoreElimPass())
       .RegisterPass(CreateLocalSingleStoreElimPass())
@@ -203,7 +203,7 @@ Optimizer& Optimizer::RegisterPerformancePasses(bool preserve_interface) {
       .RegisterPass(CreateRedundancyEliminationPass())
       .RegisterPass(CreateCombineAccessChainsPass())
       .RegisterPass(CreateSimplificationPass())
-      .RegisterPass(CreateScalarReplacementPass(0))
+      .RegisterPass(CreateScalarReplacementPass())
       .RegisterPass(CreateLocalAccessChainConvertPass())
       .RegisterPass(CreateLocalSingleBlockLoadStoreElimPass())
       .RegisterPass(CreateLocalSingleStoreElimPass())
@@ -401,7 +401,7 @@ bool Optimizer::RegisterPassFromFlag(const std::string& flag,
     RegisterPass(CreateLoopUnswitchPass());
   } else if (pass_name == "scalar-replacement") {
     if (pass_args.size() == 0) {
-      RegisterPass(CreateScalarReplacementPass(0));
+      RegisterPass(CreateScalarReplacementPass());
     } else {
       int limit = -1;
       if (pass_args.find_first_not_of("0123456789") == std::string::npos) {
@@ -637,10 +637,6 @@ bool Optimizer::RegisterPassFromFlag(const std::string& flag,
     }
   } else if (pass_name == "trim-capabilities") {
     RegisterPass(CreateTrimCapabilitiesPass());
-  } else if (pass_name == "split-combined-image-sampler") {
-    RegisterPass(CreateSplitCombinedImageSamplerPass());
-  } else if (pass_name == "resolve-binding-conflicts") {
-    RegisterPass(CreateResolveBindingConflictsPass());
   } else {
     Errorf(consumer(), nullptr, {},
            "Unknown flag '--%s'. Use --help for a list of valid flags",
@@ -1192,16 +1188,6 @@ Optimizer::PassToken CreateOpExtInstWithForwardReferenceFixupPass() {
       MakeUnique<opt::OpExtInstWithForwardReferenceFixupPass>());
 }
 
-Optimizer::PassToken CreateSplitCombinedImageSamplerPass() {
-  return MakeUnique<Optimizer::PassToken::Impl>(
-      MakeUnique<opt::SplitCombinedImageSamplerPass>());
-}
-
-Optimizer::PassToken CreateResolveBindingConflictsPass() {
-  return MakeUnique<Optimizer::PassToken::Impl>(
-      MakeUnique<opt::ResolveBindingConflictsPass>());
-}
-
 }  // namespace spvtools
 
 extern "C" {

third_party/spirv-tools/source/opt/passes.h

@@ -74,11 +74,9 @@
 #include "source/opt/remove_unused_interface_variables_pass.h"
 #include "source/opt/replace_desc_array_access_using_var_index.h"
 #include "source/opt/replace_invalid_opc.h"
-#include "source/opt/resolve_binding_conflicts_pass.h"
 #include "source/opt/scalar_replacement_pass.h"
 #include "source/opt/set_spec_constant_default_value_pass.h"
 #include "source/opt/simplification_pass.h"
-#include "source/opt/split_combined_image_sampler_pass.h"
 #include "source/opt/spread_volatile_semantics.h"
 #include "source/opt/ssa_rewrite_pass.h"
 #include "source/opt/strength_reduction_pass.h"

third_party/spirv-tools/source/opt/resolve_binding_conflicts_pass.cpp

@@ -1,328 +0,0 @@
-// Copyright (c) 2025 Google LLC
-//
-// 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 "source/opt/resolve_binding_conflicts_pass.h"
-
-#include <algorithm>
-#include <unordered_map>
-#include <unordered_set>
-#include <vector>
-
-#include "source/opt/decoration_manager.h"
-#include "source/opt/def_use_manager.h"
-#include "source/opt/instruction.h"
-#include "source/opt/ir_builder.h"
-#include "source/opt/ir_context.h"
-#include "spirv/unified1/spirv.h"
-
-namespace spvtools {
-namespace opt {
-
-// A VarBindingInfo contains the binding information for a single resource
-// variable.
-//
-// Exactly one such object is created per resource variable in the
-// module. In particular, when a resource variable is statically used by
-// more than one entry point, those entry points share the same VarBindingInfo
-// object for that variable.
-struct VarBindingInfo {
-  const Instruction* const var;
-  const uint32_t descriptor_set;
-  Instruction* const binding_decoration;
-
-  // Returns the binding number.
-  uint32_t binding() const {
-    return binding_decoration->GetSingleWordInOperand(2);
-  }
-  // Sets the binding number to 'b'.
-  void updateBinding(uint32_t b) { binding_decoration->SetOperand(2, {b}); }
-};
-
-// The bindings in the same descriptor set that are used by an entry point.
-using BindingList = std::vector<VarBindingInfo*>;
-// A map from descriptor set number to the list of bindings in that descriptor
-// set, as used by a particular entry point.
-using DescriptorSets = std::unordered_map<uint32_t, BindingList>;
-
-IRContext::Analysis ResolveBindingConflictsPass::GetPreservedAnalyses() {
-  // All analyses are kept up to date.
-  // At most this modifies the Binding numbers on variables.
-  return IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping |
-         IRContext::kAnalysisDecorations | IRContext::kAnalysisCombinators |
-         IRContext::kAnalysisCFG | IRContext::kAnalysisDominatorAnalysis |
-         IRContext::kAnalysisLoopAnalysis | IRContext::kAnalysisNameMap |
-         IRContext::kAnalysisScalarEvolution |
-         IRContext::kAnalysisRegisterPressure |
-         IRContext::kAnalysisValueNumberTable |
-         IRContext::kAnalysisStructuredCFG | IRContext::kAnalysisBuiltinVarId |
-         IRContext::kAnalysisIdToFuncMapping | IRContext::kAnalysisConstants |
-         IRContext::kAnalysisTypes | IRContext::kAnalysisDebugInfo |
-         IRContext::kAnalysisLiveness;
-}
-
-// Orders variable binding info objects.
-// * The binding number is most signficant;
-// * Then a sampler-like object compares greater than non-sampler like object.
-// * Otherwise compare based on variable ID.
-// This provides a total order among bindings in a descriptor set for a valid
-// Vulkan module.
-bool Less(const VarBindingInfo* const lhs, const VarBindingInfo* const rhs) {
-  if (lhs->binding() < rhs->binding()) return true;
-  if (lhs->binding() > rhs->binding()) return false;
-
-  // Examine types.
-  // In valid Vulkan the only conflict can occur between
-  // images and samplers.  We only care about a specific
-  // comparison when one is a image-like thing and the other
-  // is a sampler-like thing of the same shape.  So unwrap
-  // types until we hit one of those two.
-
-  auto* def_use_mgr = lhs->var->context()->get_def_use_mgr();
-
-  // Returns the type found by iteratively following pointer pointee type,
-  // or array element type.
-  auto unwrap = [&def_use_mgr](Instruction* ty) {
-    bool keep_going = true;
-    do {
-      switch (ty->opcode()) {
-        case spv::Op::OpTypePointer:
-          ty = def_use_mgr->GetDef(ty->GetSingleWordInOperand(1));
-          break;
-        case spv::Op::OpTypeArray:
-        case spv::Op::OpTypeRuntimeArray:
-          ty = def_use_mgr->GetDef(ty->GetSingleWordInOperand(0));
-          break;
-        default:
-          keep_going = false;
-          break;
-      }
-    } while (keep_going);
-    return ty;
-  };
-
-  auto* lhs_ty = unwrap(def_use_mgr->GetDef(lhs->var->type_id()));
-  auto* rhs_ty = unwrap(def_use_mgr->GetDef(rhs->var->type_id()));
-  if (lhs_ty->opcode() == rhs_ty->opcode()) {
-    // Pick based on variable ID.
-    return lhs->var->result_id() < rhs->var->result_id();
-  }
-  // A sampler is always greater than an image.
-  if (lhs_ty->opcode() == spv::Op::OpTypeSampler) {
-    return false;
-  }
-  if (rhs_ty->opcode() == spv::Op::OpTypeSampler) {
-    return true;
-  }
-  // Pick based on variable ID.
-  return lhs->var->result_id() < rhs->var->result_id();
-}
-
-// Summarizes the caller-callee relationships between functions in a module.
-class CallGraph {
- public:
-  // Returns the list of all functions statically reachable from entry points,
-  // where callees precede callers.
-  const std::vector<uint32_t>& CalleesBeforeCallers() const {
-    return visit_order_;
-  }
-  // Returns the list functions called from a given function.
-  const std::unordered_set<uint32_t>& Callees(uint32_t caller) {
-    return calls_[caller];
-  }
-
-  CallGraph(IRContext& context) {
-    // Populate calls_.
-    std::queue<uint32_t> callee_queue;
-    for (const auto& fn : *context.module()) {
-      auto& callees = calls_[fn.result_id()];
-      context.AddCalls(&fn, &callee_queue);
-      while (!callee_queue.empty()) {
-        callees.insert(callee_queue.front());
-        callee_queue.pop();
-      }
-    }
-
-    // Perform depth-first search, starting from each entry point.
-    // Populates visit_order_.
-    for (const auto& ep : context.module()->entry_points()) {
-      Visit(ep.GetSingleWordInOperand(1));
-    }
-  }
-
- private:
-  // Visits a function, recursively visiting its callees. Adds this ID
-  // to the visit_order after all callees have been visited.
-  void Visit(uint32_t func_id) {
-    if (visited_.count(func_id)) {
-      return;
-    }
-    visited_.insert(func_id);
-    for (auto callee_id : calls_[func_id]) {
-      Visit(callee_id);
-    }
-    visit_order_.push_back(func_id);
-  }
-
-  // Maps the ID of a function to the IDs of functions it calls.
-  std::unordered_map<uint32_t, std::unordered_set<uint32_t>> calls_;
-
-  // IDs of visited functions;
-  std::unordered_set<uint32_t> visited_;
-  // IDs of functions, where callees precede callers.
-  std::vector<uint32_t> visit_order_;
-};
-
-// Returns vector binding info for all resource variables in the module.
-auto GetVarBindings(IRContext& context) {
-  std::vector<VarBindingInfo> vars;
-  auto* deco_mgr = context.get_decoration_mgr();
-  for (auto& inst : context.module()->types_values()) {
-    if (inst.opcode() == spv::Op::OpVariable) {
-      Instruction* descriptor_set_deco = nullptr;
-      Instruction* binding_deco = nullptr;
-      for (auto* deco : deco_mgr->GetDecorationsFor(inst.result_id(), false)) {
-        switch (static_cast<spv::Decoration>(deco->GetSingleWordInOperand(1))) {
-          case spv::Decoration::DescriptorSet:
-            assert(!descriptor_set_deco);
-            descriptor_set_deco = deco;
-            break;
-          case spv::Decoration::Binding:
-            assert(!binding_deco);
-            binding_deco = deco;
-            break;
-          default:
-            break;
-        }
-      }
-      if (descriptor_set_deco && binding_deco) {
-        vars.push_back({&inst, descriptor_set_deco->GetSingleWordInOperand(2),
-                        binding_deco});
-      }
-    }
-  }
-  return vars;
-}
-
-// Merges the bindings from source into sink. Maintains order and uniqueness
-// within a list of bindings.
-void Merge(DescriptorSets& sink, const DescriptorSets& source) {
-  for (auto index_and_bindings : source) {
-    const uint32_t index = index_and_bindings.first;
-    const BindingList& src1 = index_and_bindings.second;
-    const BindingList& src2 = sink[index];
-    BindingList merged;
-    merged.resize(src1.size() + src2.size());
-    auto merged_end = std::merge(src1.begin(), src1.end(), src2.begin(),
-                                 src2.end(), merged.begin(), Less);
-    auto unique_end = std::unique(merged.begin(), merged_end);
-    merged.resize(unique_end - merged.begin());
-    sink[index] = std::move(merged);
-  }
-}
-
-// Resolves conflicts within this binding list, so the binding number on an
-// item is at least one more than the binding number on the previous item.
-// When this does not yet hold, increase the binding number on the second
-// item in the pair. Returns true if any changes were applied.
-bool ResolveConflicts(BindingList& bl) {
-  bool changed = false;
-  for (size_t i = 1; i < bl.size(); i++) {
-    const auto prev_num = bl[i - 1]->binding();
-    if (prev_num >= bl[i]->binding()) {
-      bl[i]->updateBinding(prev_num + 1);
-      changed = true;
-    }
-  }
-  return changed;
-}
-
-Pass::Status ResolveBindingConflictsPass::Process() {
-  // Assumes the descriptor set and binding decorations are not provided
-  // via decoration groups.  Decoration groups were deprecated in SPIR-V 1.3
-  // Revision 6.  I have not seen any compiler generate them. --dneto
-
-  auto vars = GetVarBindings(*context());
-
-  // Maps a function ID to the variables used directly or indirectly by the
-  // function, organized into descriptor sets. Each descriptor set
-  // consists of a BindingList of distinct variables.
-  std::unordered_map<uint32_t, DescriptorSets> used_vars;
-
-  // Determine variables directly used by functions.
-  auto* def_use_mgr = context()->get_def_use_mgr();
-  for (auto& var : vars) {
-    std::unordered_set<uint32_t> visited_functions_for_var;
-    def_use_mgr->ForEachUser(var.var, [&](Instruction* user) {
-      if (auto* block = context()->get_instr_block(user)) {
-        auto* fn = block->GetParent();
-        assert(fn);
-        const auto fn_id = fn->result_id();
-        if (visited_functions_for_var.insert(fn_id).second) {
-          used_vars[fn_id][var.descriptor_set].push_back(&var);
-        }
-      }
-    });
-  }
-
-  // Sort within a descriptor set by binding number.
-  for (auto& sets_for_fn : used_vars) {
-    for (auto& ds : sets_for_fn.second) {
-      BindingList& bindings = ds.second;
-      std::stable_sort(bindings.begin(), bindings.end(), Less);
-    }
-  }
-
-  // Propagate from callees to callers.
-  CallGraph call_graph(*context());
-  for (const uint32_t caller : call_graph.CalleesBeforeCallers()) {
-    DescriptorSets& caller_ds = used_vars[caller];
-    for (const uint32_t callee : call_graph.Callees(caller)) {
-      Merge(caller_ds, used_vars[callee]);
-    }
-  }
-
-  // At this point, the descriptor sets associated with each entry point
-  // capture exactly the set of resource variables statically used
-  // by the static call tree of that entry point.
-
-  // Resolve conflicts.
-  // VarBindingInfo objects may be shared between the bindings lists.
-  // Updating a binding in one list can require updating another list later.
-  // So repeat updates until settling.
-
-  // The union of BindingLists across all entry points.
-  std::vector<BindingList*> ep_bindings;
-
-  for (auto& ep : context()->module()->entry_points()) {
-    for (auto& ds : used_vars[ep.GetSingleWordInOperand(1)]) {
-      BindingList& bindings = ds.second;
-      ep_bindings.push_back(&bindings);
-    }
-  }
-  bool modified = false;
-  bool found_conflict;
-  do {
-    found_conflict = false;
-    for (BindingList* bl : ep_bindings) {
-      found_conflict |= ResolveConflicts(*bl);
-    }
-    modified |= found_conflict;
-  } while (found_conflict);
-
-  return modified ? Pass::Status::SuccessWithChange
-                  : Pass::Status::SuccessWithoutChange;
-}
-
-}  // namespace opt
-}  // namespace spvtools

third_party/spirv-tools/source/opt/resolve_binding_conflicts_pass.h

@@ -1,38 +0,0 @@
-// Copyright (c) 2025 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef LIBSPIRV_OPT_RESOLVE_BINDING_CONFLICTS_PASS_H_
-#define LIBSPIRV_OPT_RESOLVE_BINDING_CONFLICTS_PASS_H_
-
-#include <unordered_map>
-#include <utility>
-#include <vector>
-
-#include "source/diagnostic.h"
-#include "source/opt/pass.h"
-#include "source/util/small_vector.h"
-
-namespace spvtools {
-namespace opt {
-class ResolveBindingConflictsPass : public Pass {
- public:
-  virtual ~ResolveBindingConflictsPass() override = default;
-  const char* name() const override { return "resolve-binding-conflicts"; }
-  IRContext::Analysis GetPreservedAnalyses() override;
-  Status Process() override;
-};
-}  // namespace opt
-}  // namespace spvtools
-
-#endif  // LIBSPIRV_OPT_RESOLVE_BINDING_CONFLICTS_PASS_H_

third_party/spirv-tools/source/opt/scalar_replacement_pass.h

@@ -33,7 +33,7 @@ namespace opt {
 // Documented in optimizer.hpp
 class ScalarReplacementPass : public MemPass {
  private:
-  static constexpr uint32_t kDefaultLimit = 0;
+  static constexpr uint32_t kDefaultLimit = 100;
 
  public:
   ScalarReplacementPass(uint32_t limit = kDefaultLimit)

third_party/spirv-tools/source/opt/split_combined_image_sampler_pass.cpp

@@ -1,648 +0,0 @@
-// Copyright (c) 2025 Google LLC
-//
-// 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 "source/opt/split_combined_image_sampler_pass.h"
-
-#include <algorithm>
-#include <cassert>
-#include <memory>
-
-#include "source/opt/instruction.h"
-#include "source/opt/ir_builder.h"
-#include "source/opt/ir_context.h"
-#include "source/opt/type_manager.h"
-#include "source/opt/types.h"
-#include "source/util/make_unique.h"
-#include "source/util/string_utils.h"
-#include "spirv/unified1/spirv.h"
-
-namespace spvtools {
-namespace opt {
-
-#define CHECK(cond)                                          \
-  {                                                          \
-    if ((cond) != SPV_SUCCESS) return Pass::Status::Failure; \
-  }
-
-#define CHECK_STATUS(cond)                           \
-  {                                                  \
-    if (auto c = (cond); c != SPV_SUCCESS) return c; \
-  }
-
-IRContext::Analysis SplitCombinedImageSamplerPass::GetPreservedAnalyses() {
-  return
-      // def use manager is updated
-      IRContext::kAnalysisDefUse
-
-      // decorations are updated
-      | IRContext::kAnalysisDecorations
-
-      // control flow is not changed
-      | IRContext::kAnalysisCFG           //
-      | IRContext::kAnalysisLoopAnalysis  //
-      | IRContext::kAnalysisStructuredCFG
-
-      // type manager is updated
-      | IRContext::kAnalysisTypes;
-}
-
-Pass::Status SplitCombinedImageSamplerPass::Process() {
-  def_use_mgr_ = context()->get_def_use_mgr();
-  type_mgr_ = context()->get_type_mgr();
-
-  FindCombinedTextureSamplers();
-  if (combined_types_to_remove_.empty() && !sampled_image_used_as_param_) {
-    return Ok();
-  }
-
-  CHECK(RemapFunctions());
-  CHECK(RemapVars());
-  CHECK(RemoveDeadTypes());
-
-  def_use_mgr_ = nullptr;
-  type_mgr_ = nullptr;
-
-  return Ok();
-}
-
-spvtools::DiagnosticStream SplitCombinedImageSamplerPass::Fail() {
-  return std::move(
-      spvtools::DiagnosticStream({}, consumer(), "", SPV_ERROR_INVALID_BINARY)
-      << "split-combined-image-sampler: ");
-}
-
-void SplitCombinedImageSamplerPass::FindCombinedTextureSamplers() {
-  for (auto& inst : context()->types_values()) {
-    RegisterGlobal(inst.result_id());
-    switch (inst.opcode()) {
-      case spv::Op::OpTypeSampler:
-        // Modules can't have duplicate sampler types.
-        assert(!sampler_type_);
-        sampler_type_ = &inst;
-        break;
-
-      case spv::Op::OpTypeSampledImage:
-        if (!first_sampled_image_type_) {
-          first_sampled_image_type_ = &inst;
-        }
-        combined_types_.insert(inst.result_id());
-        def_use_mgr_->WhileEachUser(inst.result_id(), [&](Instruction* i) {
-          sampled_image_used_as_param_ |=
-              i->opcode() == spv::Op::OpTypeFunction;
-          return !sampled_image_used_as_param_;
-        });
-        break;
-
-      case spv::Op::OpTypeArray:
-      case spv::Op::OpTypeRuntimeArray: {
-        auto pointee_id = inst.GetSingleWordInOperand(0);
-        if (combined_types_.find(pointee_id) != combined_types_.end()) {
-          combined_types_.insert(inst.result_id());
-          combined_types_to_remove_.push_back(inst.result_id());
-        }
-      } break;
-
-      case spv::Op::OpTypePointer: {
-        auto sc =
-            static_cast<spv::StorageClass>(inst.GetSingleWordInOperand(0));
-        if (sc == spv::StorageClass::UniformConstant) {
-          auto pointee_id = inst.GetSingleWordInOperand(1);
-          if (combined_types_.find(pointee_id) != combined_types_.end()) {
-            combined_types_.insert(inst.result_id());
-            combined_types_to_remove_.push_back(inst.result_id());
-          }
-        }
-      } break;
-
-      case spv::Op::OpVariable:
-        if (combined_types_.find(inst.type_id()) != combined_types_.end()) {
-          ordered_vars_.push_back(&inst);
-        }
-        break;
-
-      default:
-        break;
-    }
-  }
-}
-
-Instruction* SplitCombinedImageSamplerPass::GetSamplerType() {
-  if (!sampler_type_) {
-    analysis::Sampler s;
-    uint32_t sampler_type_id = type_mgr_->GetTypeInstruction(&s);
-    sampler_type_ = def_use_mgr_->GetDef(sampler_type_id);
-    assert(first_sampled_image_type_);
-    sampler_type_->InsertBefore(first_sampled_image_type_);
-    RegisterNewGlobal(sampler_type_->result_id());
-  }
-  return sampler_type_;
-}
-
-spv_result_t SplitCombinedImageSamplerPass::RemapVars() {
-  for (Instruction* var : ordered_vars_) {
-    CHECK_STATUS(RemapVar(var));
-  }
-  return SPV_SUCCESS;
-}
-
-std::pair<Instruction*, Instruction*> SplitCombinedImageSamplerPass::SplitType(
-    Instruction& combined_kind_type) {
-  if (auto where = type_remap_.find(combined_kind_type.result_id());
-      where != type_remap_.end()) {
-    auto& type_remap = where->second;
-    return {type_remap.image_kind_type, type_remap.sampler_kind_type};
-  }
-
-  switch (combined_kind_type.opcode()) {
-    case spv::Op::OpTypeSampledImage: {
-      auto* image_type =
-          def_use_mgr_->GetDef(combined_kind_type.GetSingleWordInOperand(0));
-      auto* sampler_type = GetSamplerType();
-      type_remap_[combined_kind_type.result_id()] = {&combined_kind_type,
-                                                     image_type, sampler_type};
-      return {image_type, sampler_type};
-      break;
-    }
-    case spv::Op::OpTypePointer: {
-      auto sc = static_cast<spv::StorageClass>(
-          combined_kind_type.GetSingleWordInOperand(0));
-      if (sc == spv::StorageClass::UniformConstant) {
-        auto* pointee =
-            def_use_mgr_->GetDef(combined_kind_type.GetSingleWordInOperand(1));
-        auto [image_pointee, sampler_pointee] = SplitType(*pointee);
-        // These would be null if the pointee is an image type or a sampler
-        // type. Don't decompose them. Currently this method does not check the
-        // assumption that it is being only called on combined types. So code
-        // this defensively.
-        if (image_pointee && sampler_pointee) {
-          auto* ptr_image = MakeUniformConstantPointer(image_pointee);
-          auto* ptr_sampler = MakeUniformConstantPointer(sampler_pointee);
-          type_remap_[combined_kind_type.result_id()] = {
-              &combined_kind_type, ptr_image, ptr_sampler};
-          return {ptr_image, ptr_sampler};
-        }
-      }
-      break;
-    }
-    case spv::Op::OpTypeArray: {
-      const auto* array_ty =
-          type_mgr_->GetType(combined_kind_type.result_id())->AsArray();
-      assert(array_ty);
-      const auto* sampled_image_ty = array_ty->element_type()->AsSampledImage();
-      assert(sampled_image_ty);
-
-      const analysis::Type* image_ty = sampled_image_ty->image_type();
-      assert(image_ty);
-      analysis::Array array_image_ty(image_ty, array_ty->length_info());
-      const uint32_t array_image_ty_id =
-          type_mgr_->GetTypeInstruction(&array_image_ty);
-      auto* array_image_ty_inst = def_use_mgr_->GetDef(array_image_ty_id);
-      if (!IsKnownGlobal(array_image_ty_id)) {
-        array_image_ty_inst->InsertBefore(&combined_kind_type);
-        RegisterNewGlobal(array_image_ty_id);
-        // GetTypeInstruction also updated the def-use manager.
-      }
-
-      analysis::Array sampler_array_ty(
-          type_mgr_->GetType(GetSamplerType()->result_id()),
-          array_ty->length_info());
-      const uint32_t array_sampler_ty_id =
-          type_mgr_->GetTypeInstruction(&sampler_array_ty);
-      auto* array_sampler_ty_inst = def_use_mgr_->GetDef(array_sampler_ty_id);
-      if (!IsKnownGlobal(array_sampler_ty_id)) {
-        array_sampler_ty_inst->InsertBefore(&combined_kind_type);
-        RegisterNewGlobal(array_sampler_ty_id);
-        // GetTypeInstruction also updated the def-use manager.
-      }
-      return {array_image_ty_inst, array_sampler_ty_inst};
-    }
-    case spv::Op::OpTypeRuntimeArray: {
-      // This is like the sized-array case, but there is no length parameter.
-      auto* array_ty =
-          type_mgr_->GetType(combined_kind_type.result_id())->AsRuntimeArray();
-      assert(array_ty);
-      auto* sampled_image_ty = array_ty->element_type()->AsSampledImage();
-      assert(sampled_image_ty);
-
-      const analysis::Type* image_ty = sampled_image_ty->image_type();
-      assert(image_ty);
-      analysis::RuntimeArray array_image_ty(image_ty);
-      const uint32_t array_image_ty_id =
-          type_mgr_->GetTypeInstruction(&array_image_ty);
-      auto* array_image_ty_inst = def_use_mgr_->GetDef(array_image_ty_id);
-      if (!IsKnownGlobal(array_image_ty_id)) {
-        array_image_ty_inst->InsertBefore(&combined_kind_type);
-        RegisterNewGlobal(array_image_ty_id);
-        // GetTypeInstruction also updated the def-use manager.
-      }
-
-      analysis::RuntimeArray sampler_array_ty(
-          type_mgr_->GetType(GetSamplerType()->result_id()));
-      const uint32_t array_sampler_ty_id =
-          type_mgr_->GetTypeInstruction(&sampler_array_ty);
-      auto* array_sampler_ty_inst = def_use_mgr_->GetDef(array_sampler_ty_id);
-      if (!IsKnownGlobal(array_sampler_ty_id)) {
-        array_sampler_ty_inst->InsertBefore(&combined_kind_type);
-        RegisterNewGlobal(array_sampler_ty_id);
-        // GetTypeInstruction also updated the def-use manager.
-      }
-      return {array_image_ty_inst, array_sampler_ty_inst};
-    }
-    default:
-      break;
-  }
-  return {nullptr, nullptr};
-}
-
-spv_result_t SplitCombinedImageSamplerPass::RemapVar(
-    Instruction* combined_var) {
-  InstructionBuilder builder(context(), combined_var,
-                             IRContext::kAnalysisDefUse);
-
-  // Create an image variable, and a sampler variable.
-  auto* combined_var_type = def_use_mgr_->GetDef(combined_var->type_id());
-  auto [ptr_image_ty, ptr_sampler_ty] = SplitType(*combined_var_type);
-  assert(ptr_image_ty);
-  assert(ptr_sampler_ty);
-  Instruction* sampler_var = builder.AddVariable(
-      ptr_sampler_ty->result_id(), SpvStorageClassUniformConstant);
-  Instruction* image_var = builder.AddVariable(ptr_image_ty->result_id(),
-                                               SpvStorageClassUniformConstant);
-  modified_ = true;
-  return RemapUses(combined_var, image_var, sampler_var);
-}
-
-spv_result_t SplitCombinedImageSamplerPass::RemapUses(
-    Instruction* combined, Instruction* image_part, Instruction* sampler_part) {
-  // The instructions to delete.
-  std::unordered_set<Instruction*> dead_insts;
-  // The insertion point should be updated before using this builder.
-  // We needed *something* here.
-  InstructionBuilder builder(context(), combined, IRContext::kAnalysisDefUse);
-
-  // This code must maintain the SPIR-V "Data rule" about sampled image values:
-  //  > All OpSampledImage instructions, or instructions that load an image or
-  //  > sampler reference, must be in the same block in which their Result <id>
-  //  > are consumed.
-  //
-  // When the code below inserts OpSampledImage instructions, it is always
-  // either:
-  // - in the same block as the previous OpSampledImage instruction it is
-  //   replacing, or
-  // - in the same block as the instruction using sampled image value it is
-  //   replacing.
-  //
-  // Assuming that rule is already honoured by the module, these updates will
-  // continue to honour the rule.
-
-  // Represents a single use of a value to be remapped.
-  struct RemapUse {
-    uint32_t used_id;  // The ID that is being used.
-    Instruction* user;
-    uint32_t index;
-    Instruction* image_part;    // The image part of the replacement.
-    Instruction* sampler_part;  // The sampler part of the replacement.
-  };
-  // The work list of uses to be remapped.
-  std::vector<RemapUse> uses;
-
-  // Adds remap records for each use of a value to be remapped.
-  // Also schedules the original value for deletion.
-  auto add_remap = [this, &dead_insts, &uses](Instruction* combined_arg,
-                                              Instruction* image_part_arg,
-                                              Instruction* sampler_part_arg) {
-    const uint32_t used_combined_id = combined_arg->result_id();
-
-    def_use_mgr_->ForEachUse(
-        combined_arg, [&](Instruction* user, uint32_t use_index) {
-          uses.push_back({used_combined_id, user, use_index, image_part_arg,
-                          sampler_part_arg});
-        });
-    dead_insts.insert(combined_arg);
-  };
-
-  add_remap(combined, image_part, sampler_part);
-
-  // Use index-based iteration because we can add to the work list as we go
-  // along, and reallocation would invalidate ordinary iterators.
-  for (size_t use_index = 0; use_index < uses.size(); ++use_index) {
-    auto& use = uses[use_index];
-    switch (use.user->opcode()) {
-      case spv::Op::OpCopyObject: {
-        // Append the uses of this OpCopyObject to the work list.
-        add_remap(use.user, image_part, sampler_part);
-        break;
-      }
-      case spv::Op::OpLoad: {
-        assert(use.index == 2 && "variable used as non-pointer index on load");
-        Instruction* load = use.user;
-
-        // Assume the loaded value is a sampled image.
-        assert(def_use_mgr_->GetDef(load->type_id())->opcode() ==
-               spv::Op::OpTypeSampledImage);
-
-        // Create loads for the image part and sampler part.
-        builder.SetInsertPoint(load);
-        auto* image = builder.AddLoad(PointeeTypeId(use.image_part),
-                                      use.image_part->result_id());
-        auto* sampler = builder.AddLoad(PointeeTypeId(use.sampler_part),
-                                        use.sampler_part->result_id());
-
-        // Move decorations, such as RelaxedPrecision.
-        auto* deco_mgr = context()->get_decoration_mgr();
-        deco_mgr->CloneDecorations(load->result_id(), image->result_id());
-        deco_mgr->CloneDecorations(load->result_id(), sampler->result_id());
-        deco_mgr->RemoveDecorationsFrom(load->result_id());
-
-        // Create a sampled image from the loads of the two parts.
-        auto* sampled_image = builder.AddSampledImage(
-            load->type_id(), image->result_id(), sampler->result_id());
-        // Replace the original sampled image value with the new one.
-        std::unordered_set<Instruction*> users;
-        def_use_mgr_->ForEachUse(
-            load, [&users, sampled_image](Instruction* user, uint32_t index) {
-              user->SetOperand(index, {sampled_image->result_id()});
-              users.insert(user);
-            });
-        for (auto* user : users) {
-          def_use_mgr_->AnalyzeInstUse(user);
-        }
-        dead_insts.insert(load);
-        break;
-      }
-      case spv::Op::OpDecorate: {
-        assert(use.index == 0 && "variable used as non-target index");
-        builder.SetInsertPoint(use.user);
-        spv::Decoration deco{use.user->GetSingleWordInOperand(1)};
-        std::vector<uint32_t> literals;
-        for (uint32_t i = 2; i < use.user->NumInOperands(); i++) {
-          literals.push_back(use.user->GetSingleWordInOperand(i));
-        }
-        builder.AddDecoration(use.image_part->result_id(), deco, literals);
-        builder.AddDecoration(use.sampler_part->result_id(), deco, literals);
-        // KillInst will delete names and decorations, so don't schedule a
-        // deletion of this instruction.
-        break;
-      }
-      case spv::Op::OpEntryPoint: {
-        // The entry point lists variables in the shader interface, i.e.
-        // module-scope variables referenced by the static call tree rooted
-        // at the entry point. (It can be a proper superset).  Before SPIR-V
-        // 1.4, only Input and Output variables are listed; in 1.4 and later,
-        // module-scope variables in all storage classes are listed.
-        // If a combined image+sampler is listed by the entry point, then
-        // the separated image and sampler variables should be.
-        assert(use.index >= 3 &&
-               "variable used in OpEntryPoint but not as an interface ID");
-        use.user->SetOperand(use.index, {use.image_part->result_id()});
-        use.user->InsertOperand(
-            use.user->NumOperands(),
-            {SPV_OPERAND_TYPE_ID, {use.sampler_part->result_id()}});
-        def_use_mgr_->AnalyzeInstUse(use.user);
-        break;
-      }
-      case spv::Op::OpName: {
-        // Synthesize new names from the old.
-        const auto name = use.user->GetOperand(1).AsString();
-        AddOpName(use.image_part->result_id(), name + "_image");
-        AddOpName(use.sampler_part->result_id(), name + "_sampler");
-
-        // KillInst will delete names and decorations, so don't schedule a
-        // deletion of this instruction.
-        break;
-      }
-      case spv::Op::OpFunctionCall: {
-        // Replace each combined arg with two args: the image part, then the
-        // sampler part.
-        // The combined value could have been used twice in the argument list.
-        // Moving things around now will invalidate the 'use' list above.
-        // So don't trust the use index value.
-        auto& call = *use.user;
-        // The insert API only takes absolute arg IDs, not "in" arg IDs.
-        const auto first_arg_operand_index = 3;  // Skip the callee ID
-        for (uint32_t i = first_arg_operand_index; i < call.NumOperands();
-             ++i) {
-          if (use.used_id == call.GetSingleWordOperand(i)) {
-            call.SetOperand(i, {use.sampler_part->result_id()});
-            call.InsertOperand(
-                i, {SPV_OPERAND_TYPE_ID, {use.image_part->result_id()}});
-            ++i;
-          }
-        }
-        def_use_mgr_->AnalyzeInstUse(&call);
-        break;
-      }
-      case spv::Op::OpAccessChain:
-      case spv::Op::OpInBoundsAccessChain: {
-        auto* original_access_chain = use.user;
-        builder.SetInsertPoint(original_access_chain);
-        // It can only be the base pointer
-        assert(use.index == 2);
-
-        // Replace the original access chain with access chains for the image
-        // part and the sampler part.
-        std::vector<uint32_t> indices;
-        for (uint32_t i = 3; i < original_access_chain->NumOperands(); i++) {
-          indices.push_back(original_access_chain->GetSingleWordOperand(i));
-        }
-
-        auto [result_image_part_ty, result_sampler_part_ty] =
-            SplitType(*def_use_mgr_->GetDef(original_access_chain->type_id()));
-        auto* result_image_part = builder.AddOpcodeAccessChain(
-            use.user->opcode(), result_image_part_ty->result_id(),
-            use.image_part->result_id(), indices);
-        auto* result_sampler_part = builder.AddOpcodeAccessChain(
-            use.user->opcode(), result_sampler_part_ty->result_id(),
-            use.sampler_part->result_id(), indices);
-
-        // Remap uses of the original access chain.
-        add_remap(original_access_chain, result_image_part,
-                  result_sampler_part);
-        break;
-      }
-      default: {
-        uint32_t used_type_id = def_use_mgr_->GetDef(use.used_id)->type_id();
-        auto* used_type = def_use_mgr_->GetDef(used_type_id);
-        if (used_type->opcode() == spv::Op::OpTypeSampledImage) {
-          // This value being used is a sampled image value.  But it's
-          // being replaced, so recreate it here.
-          // Example: used by OpImage, OpImageSampleExplicitLod, etc.
-          builder.SetInsertPoint(use.user);
-          auto* sampled_image =
-              builder.AddSampledImage(used_type_id, use.image_part->result_id(),
-                                      use.sampler_part->result_id());
-          use.user->SetOperand(use.index, {sampled_image->result_id()});
-          def_use_mgr_->AnalyzeInstUse(use.user);
-          break;
-        }
-        return Fail() << "unhandled user: " << *use.user;
-      }
-    }
-  }
-
-  for (auto* inst : dead_insts) {
-    KillInst(inst);
-  }
-
-  return SPV_SUCCESS;
-}
-
-spv_result_t SplitCombinedImageSamplerPass::RemapFunctions() {
-  // Remap function types. A combined type can appear as a parameter, but not as
-  // the return type.
-  {
-    std::unordered_set<Instruction*> dead_insts;
-    for (auto& inst : context()->types_values()) {
-      if (inst.opcode() != spv::Op::OpTypeFunction) {
-        continue;
-      }
-      analysis::Function* f_ty =
-          type_mgr_->GetType(inst.result_id())->AsFunction();
-      std::vector<const analysis::Type*> new_params;
-      for (const auto* param_ty : f_ty->param_types()) {
-        const auto param_ty_id = type_mgr_->GetId(param_ty);
-        if (combined_types_.find(param_ty_id) != combined_types_.end()) {
-          auto* param_type = def_use_mgr_->GetDef(param_ty_id);
-          auto [image_type, sampler_type] = SplitType(*param_type);
-          assert(image_type);
-          assert(sampler_type);
-          // The image and sampler types must already exist, so there is no
-          // need to move them to the right spot.
-          new_params.push_back(type_mgr_->GetType(image_type->result_id()));
-          new_params.push_back(type_mgr_->GetType(sampler_type->result_id()));
-        } else {
-          new_params.push_back(param_ty);
-        }
-      }
-      if (new_params.size() != f_ty->param_types().size()) {
-        // Replace this type.
-        analysis::Function new_f_ty(f_ty->return_type(), new_params);
-        const uint32_t new_f_ty_id = type_mgr_->GetTypeInstruction(&new_f_ty);
-        std::unordered_set<Instruction*> users;
-        def_use_mgr_->ForEachUse(
-            &inst,
-            [&users, new_f_ty_id](Instruction* user, uint32_t use_index) {
-              user->SetOperand(use_index, {new_f_ty_id});
-              users.insert(user);
-            });
-        for (auto* user : users) {
-          def_use_mgr_->AnalyzeInstUse(user);
-        }
-        dead_insts.insert(&inst);
-      }
-    }
-    for (auto* inst : dead_insts) {
-      KillInst(inst);
-    }
-  }
-
-  // Rewite OpFunctionParameter in function definitions.
-  for (Function& fn : *context()->module()) {
-    // Rewrite the function parameters and record their replacements.
-    struct Replacement {
-      Instruction* combined;
-      Instruction* image;
-      Instruction* sampler;
-    };
-    std::vector<Replacement> replacements;
-
-    Function::RewriteParamFn rewriter =
-        [&](std::unique_ptr<Instruction>&& param,
-            std::back_insert_iterator<Function::ParamList>& appender) {
-          if (combined_types_.count(param->type_id()) == 0) {
-            appender = std::move(param);
-            return;
-          }
-
-          // Replace this parameter with two new parameters.
-          auto* combined_inst = param.release();
-          auto* combined_type = def_use_mgr_->GetDef(combined_inst->type_id());
-          auto [image_type, sampler_type] = SplitType(*combined_type);
-          auto image_param = MakeUnique<Instruction>(
-              context(), spv::Op::OpFunctionParameter, image_type->result_id(),
-              context()->TakeNextId(), Instruction::OperandList{});
-          auto sampler_param = MakeUnique<Instruction>(
-              context(), spv::Op::OpFunctionParameter,
-              sampler_type->result_id(), context()->TakeNextId(),
-              Instruction::OperandList{});
-          replacements.push_back(
-              {combined_inst, image_param.get(), sampler_param.get()});
-          appender = std::move(image_param);
-          appender = std::move(sampler_param);
-        };
-    fn.RewriteParams(rewriter);
-
-    for (auto& r : replacements) {
-      modified_ = true;
-      def_use_mgr_->AnalyzeInstDefUse(r.image);
-      def_use_mgr_->AnalyzeInstDefUse(r.sampler);
-      CHECK_STATUS(RemapUses(r.combined, r.image, r.sampler));
-    }
-  }
-  return SPV_SUCCESS;
-}
-
-Instruction* SplitCombinedImageSamplerPass::MakeUniformConstantPointer(
-    Instruction* pointee) {
-  uint32_t ptr_id = type_mgr_->FindPointerToType(
-      pointee->result_id(), spv::StorageClass::UniformConstant);
-  auto* ptr = def_use_mgr_->GetDef(ptr_id);
-  if (!IsKnownGlobal(ptr_id)) {
-    // The pointer type was created at the end. Put it right after the
-    // pointee.
-    ptr->InsertBefore(pointee);
-    pointee->InsertBefore(ptr);
-    RegisterNewGlobal(ptr_id);
-    // FindPointerToType also updated the def-use manager.
-  }
-  return ptr;
-}
-
-void SplitCombinedImageSamplerPass::AddOpName(uint32_t id,
-                                              const std::string& name) {
-  std::unique_ptr<Instruction> opname{new Instruction{
-      context(),
-      spv::Op::OpName,
-      0u,
-      0u,
-      {{SPV_OPERAND_TYPE_ID, {id}},
-       {SPV_OPERAND_TYPE_LITERAL_STRING,
-        utils::MakeVector<spvtools::opt::Operand::OperandData>(name)}}}};
-
-  context()->AddDebug2Inst(std::move(opname));
-}
-
-spv_result_t SplitCombinedImageSamplerPass::RemoveDeadTypes() {
-  for (auto dead_type_id : combined_types_to_remove_) {
-    if (auto* ty = def_use_mgr_->GetDef(dead_type_id)) {
-      KillInst(ty);
-    }
-  }
-  return SPV_SUCCESS;
-}
-
-void SplitCombinedImageSamplerPass::KillInst(Instruction* inst) {
-  // IRContext::KillInst will remove associated debug instructions and
-  // decorations. It will delete the object only if it is already in a list.
-  const bool was_in_list = inst->IsInAList();
-  context()->KillInst(inst);
-  if (!was_in_list) {
-    // Avoid leaking
-    delete inst;
-  }
-  modified_ = true;
-}
-
-}  // namespace opt
-}  // namespace spvtools

third_party/spirv-tools/source/opt/split_combined_image_sampler_pass.h

@@ -1,169 +0,0 @@
-// Copyright (c) 2025 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef LIBSPIRV_OPT_SPLIT_COMBINED_IMAGE_SAMPLER_PASS_H_
-#define LIBSPIRV_OPT_SPLIT_COMBINED_IMAGE_SAMPLER_PASS_H_
-
-#include <unordered_map>
-#include <utility>
-#include <vector>
-
-#include "source/diagnostic.h"
-#include "source/opt/decoration_manager.h"
-#include "source/opt/def_use_manager.h"
-#include "source/opt/pass.h"
-#include "source/opt/type_manager.h"
-
-namespace spvtools {
-namespace opt {
-
-// Replaces each combined-image sampler variable with an image variable
-// and a sampler variable. Similar for function parameters.
-//
-// Copy the descriptor set and binding number. Vulkan allows this, surprisingly.
-class SplitCombinedImageSamplerPass : public Pass {
- public:
-  virtual ~SplitCombinedImageSamplerPass() override = default;
-  const char* name() const override { return "split-combined-image-sampler"; }
-  IRContext::Analysis GetPreservedAnalyses() override;
-  Status Process() override;
-
- private:
-  // Records failure for the current module, and returns a stream
-  // that can be used to provide user error information to the message
-  // consumer.
-  spvtools::DiagnosticStream Fail();
-
-  // Find variables that contain combined texture-samplers, or arrays of them.
-  // Also populate known_globals_.
-  void FindCombinedTextureSamplers();
-
-  // Returns the sampler type. If it does not yet exist, then it is created
-  // and placed before the first sampled image type.
-  Instruction* GetSamplerType();
-
-  // Remaps function types and function declarations.  Each
-  // pointer-to-sampled-image-type operand is replaced with a pair of
-  // pointer-to-image-type and pointer-to-sampler-type pair.
-  // Updates the def-use manager and type manager.
-  spv_result_t RemapFunctions();
-  // Remap resource variables.
-  // Updates the def-use manager.
-  spv_result_t RemapVars();
-  // Remap a single resource variable for combined var.
-  // Updates the def-use manager and the decorations manager.
-  spv_result_t RemapVar(Instruction* combined_var);
-  // Transitively remaps uses of the combined object with uses of the
-  // decomposed image and sampler parts.  The combined object can be sampled
-  // image value, a pointer to one, an array of one, or a pointer to an array
-  // of one. The image and sampler parts have corresponding shapes.
-  // Updates the def-use manager and the decorations manager.
-  spv_result_t RemapUses(Instruction* combined, Instruction* image_part,
-                         Instruction* sampler_part);
-  // Removes types that are no longer referenced.
-  spv_result_t RemoveDeadTypes();
-
-  // Returns the type instruction for a UniformConstant pointer to the given
-  // pointee type. If it does not yet exist, the new type instruction is created
-  // and placed immediately after the pointee type instruction. Updates def-use
-  // and type managers, and the set of known globals.
-  Instruction* MakeUniformConstantPointer(Instruction* pointee);
-
-  // Returns the ID of the pointee type for a pointer value instruction.
-  uint32_t PointeeTypeId(Instruction* ptr_value) {
-    auto* ptr_ty = def_use_mgr_->GetDef(ptr_value->type_id());
-    assert(ptr_ty->opcode() == spv::Op::OpTypePointer);
-    return ptr_ty->GetSingleWordInOperand(1);
-  }
-
-  // Creates a new OpName instruction mapping the given name to the given
-  // string, and adds it to the module at the end of the OpName and OpMemberName
-  // section.
-  void AddOpName(uint32_t id, const std::string& name);
-
-  // Cached from the IRContext. Valid while Process() is running.
-  analysis::DefUseManager* def_use_mgr_ = nullptr;
-  // Cached from the IRContext. Valid while Process() is running.
-  analysis::TypeManager* type_mgr_ = nullptr;
-
-  // Did processing modify the module?
-  bool modified_ = false;
-  Pass::Status Ok() {
-    return modified_ ? Pass::Status::SuccessWithChange
-                     : Pass::Status::SuccessWithoutChange;
-  }
-
-  // The first OpTypeSampledImage instruction in the module, if one exists.
-  Instruction* first_sampled_image_type_ = nullptr;
-  // An OpTypeSampler instruction, if one existed already, or if we created one.
-  Instruction* sampler_type_ = nullptr;
-
-  // The known types and module-scope values.
-  // We use this to know when a new such value was created.
-  std::unordered_set<uint32_t> known_globals_;
-  bool IsKnownGlobal(uint32_t id) const {
-    return known_globals_.find(id) != known_globals_.end();
-  }
-  void RegisterGlobal(uint32_t id) { known_globals_.insert(id); }
-  void RegisterNewGlobal(uint32_t id) {
-    modified_ = true;
-    RegisterGlobal(id);
-  }
-
-  // Deletes an instruction and associated debug and decoration instructions.
-  // Updates the def-use manager.
-  void KillInst(Instruction* inst);
-
-  // Combined types.  The known combined sampled-image type,
-  // and recursively pointers or arrays of them.
-  std::unordered_set<uint32_t> combined_types_;
-  // The pre-existing types this pass should remove: pointer to
-  // combined type, array of combined type, pointer to array of combined type.
-  std::vector<uint32_t> combined_types_to_remove_;
-  // Is an OpTypeSampledImage used as a function parameter? Those should be
-  // transformed.
-  bool sampled_image_used_as_param_ = false;
-
-  // Remaps a combined-kind type to corresponding sampler-kind and image-kind
-  // of type.
-  struct TypeRemapInfo {
-    // The instruction for the combined type, pointer to combined type,
-    // or point to array of combined type.
-    Instruction* combined_kind_type;
-    // The corresponding image type, with the same shape of indirection as the
-    // combined_kind_type.
-    Instruction* image_kind_type;
-    // The corresponding sampler type, with the same shape of indirection as the
-    // combined_kind_type.
-    Instruction* sampler_kind_type;
-  };
-  // Maps the ID of a combined-image-sampler type kind to its corresponding
-  // split parts.
-  std::unordered_map<uint32_t, TypeRemapInfo> type_remap_;
-
-  // Returns the image-like and sampler-like types of the same indirection shape
-  // as the given combined-like type.  If combined_kind_type is not a combined
-  // type or a pointer to one, or an array of one or a pointer to an array of
-  // one, then returns a pair of null pointer. Either both components are
-  // non-null, or both components are null. Updates the def-use manager and the
-  // type manager if new instructions are created.
-  std::pair<Instruction*, Instruction*> SplitType(
-      Instruction& combined_kind_type);
-
-  // The combined-image-sampler variables to be replaced.
-  std::vector<Instruction*> ordered_vars_;
-};
-}  // namespace opt
-}  // namespace spvtools
-#endif  // LIBSPIRV_OPT_SPLIT_COMBINED_IMAGE_SAMPLER_PASS_H_

third_party/spirv-tools/source/opt/trim_capabilities_pass.cpp

@@ -241,37 +241,6 @@ Handler_OpTypePointer_StorageUniformBufferBlock16(
              : std::nullopt;
 }
 
-static std::optional<spv::Capability>
-Handler_OpTypePointer_StorageBuffer16BitAccess(const Instruction* instruction) {
-  assert(instruction->opcode() == spv::Op::OpTypePointer &&
-         "This handler only support OpTypePointer opcodes.");
-
-  // Requires StorageBuffer, ShaderRecordBufferKHR or PhysicalStorageBuffer
-  // storage classes.
-  spv::StorageClass storage_class = spv::StorageClass(
-      instruction->GetSingleWordInOperand(kOpTypePointerStorageClassIndex));
-  if (storage_class != spv::StorageClass::StorageBuffer &&
-      storage_class != spv::StorageClass::ShaderRecordBufferKHR &&
-      storage_class != spv::StorageClass::PhysicalStorageBuffer) {
-    return std::nullopt;
-  }
-
-  const auto* decoration_mgr = instruction->context()->get_decoration_mgr();
-  const bool matchesCondition =
-      AnyTypeOf(instruction, [decoration_mgr](const Instruction* item) {
-        if (!decoration_mgr->HasDecoration(item->result_id(),
-                                           spv::Decoration::Block)) {
-          return false;
-        }
-
-        return AnyTypeOf(item, is16bitType);
-      });
-
-  return matchesCondition
-             ? std::optional(spv::Capability::StorageBuffer16BitAccess)
-             : std::nullopt;
-}
-
 static std::optional<spv::Capability> Handler_OpTypePointer_StorageUniform16(
     const Instruction* instruction) {
   assert(instruction->opcode() == spv::Op::OpTypePointer &&
@@ -419,7 +388,7 @@ Handler_OpImageSparseRead_StorageImageReadWithoutFormat(
 }
 
 // Opcode of interest to determine capabilities requirements.
-constexpr std::array<std::pair<spv::Op, OpcodeHandler>, 14> kOpcodeHandlers{{
+constexpr std::array<std::pair<spv::Op, OpcodeHandler>, 13> kOpcodeHandlers{{
     // clang-format off
     {spv::Op::OpImageRead,         Handler_OpImageRead_StorageImageReadWithoutFormat},
     {spv::Op::OpImageWrite,        Handler_OpImageWrite_StorageImageWriteWithoutFormat},
@@ -434,7 +403,6 @@ constexpr std::array<std::pair<spv::Op, OpcodeHandler>, 14> kOpcodeHandlers{{
     {spv::Op::OpTypePointer,       Handler_OpTypePointer_StorageUniform16},
     {spv::Op::OpTypePointer,       Handler_OpTypePointer_StorageUniform16},
     {spv::Op::OpTypePointer,       Handler_OpTypePointer_StorageUniformBufferBlock16},
-    {spv::Op::OpTypePointer,       Handler_OpTypePointer_StorageBuffer16BitAccess},
     // clang-format on
 }};
 

third_party/spirv-tools/source/opt/trim_capabilities_pass.h

@@ -99,7 +99,6 @@ class TrimCapabilitiesPass : public Pass {
       spv::Capability::RayTraversalPrimitiveCullingKHR,
       spv::Capability::Shader,
       spv::Capability::ShaderClockKHR,
-      spv::Capability::StorageBuffer16BitAccess,
       spv::Capability::StorageImageReadWithoutFormat,
       spv::Capability::StorageImageWriteWithoutFormat,
       spv::Capability::StorageInputOutput16,

third_party/spirv-tools/source/opt/type_manager.cpp

@@ -495,8 +495,6 @@ uint32_t TypeManager::GetTypeInstruction(const Type* type) {
       break;
   }
   context()->AddType(std::move(typeInst));
-  // TODO(dneto): This next call to AnalyzeDefUse is redundant becaues
-  // IRContext::AddType already does it.
   context()->AnalyzeDefUse(&*--context()->types_values_end());
   AttachDecorations(id, type);
   return id;

third_party/spirv-tools/source/opt/value_number_table.cpp

@@ -45,43 +45,28 @@ uint32_t ValueNumberTable::AssignValueNumber(Instruction* inst) {
     return value;
   }
 
-  auto assign_new_number = [this](Instruction* i) {
-    const auto new_value = TakeNextValueNumber();
-    id_to_value_[i->result_id()] = new_value;
-    return new_value;
-  };
-
   // If the instruction has other side effects, then it must
   // have its own value number.
-  if (!context()->IsCombinatorInstruction(inst) &&
-      !inst->IsCommonDebugInstr()) {
-    return assign_new_number(inst);
-  }
-
   // OpSampledImage and OpImage must remain in the same basic block in which
   // they are used, because of this we will assign each one it own value number.
+  if (!context()->IsCombinatorInstruction(inst) &&
+      !inst->IsCommonDebugInstr()) {
+    value = TakeNextValueNumber();
+    id_to_value_[inst->result_id()] = value;
+    return value;
+  }
+
   switch (inst->opcode()) {
     case spv::Op::OpSampledImage:
     case spv::Op::OpImage:
     case spv::Op::OpVariable:
-      return assign_new_number(inst);
+      value = TakeNextValueNumber();
+      id_to_value_[inst->result_id()] = value;
+      return value;
     default:
       break;
   }
 
-  // A load that yields an image, sampler, or sampled image must remain in
-  // the same basic block.  So assign it its own value number.
-  if (inst->IsLoad()) {
-    switch (context()->get_def_use_mgr()->GetDef(inst->type_id())->opcode()) {
-      case spv::Op::OpTypeSampledImage:
-      case spv::Op::OpTypeImage:
-      case spv::Op::OpTypeSampler:
-        return assign_new_number(inst);
-      default:
-        break;
-    }
-  }
-
   // If it is a load from memory that can be modified, we have to assume the
   // memory has been modified, so we give it a new value number.
   //
@@ -89,7 +74,9 @@ uint32_t ValueNumberTable::AssignValueNumber(Instruction* inst) {
   // read only.  However, if this is ever relaxed because we analyze stores, we
   // will have to add a new case for volatile loads.
   if (inst->IsLoad() && !inst->IsReadOnlyLoad()) {
-    return assign_new_number(inst);
+    value = TakeNextValueNumber();
+    id_to_value_[inst->result_id()] = value;
+    return value;
   }
 
   analysis::DecorationManager* dec_mgr = context()->get_decoration_mgr();

third_party/spirv-tools/source/spirv_validator_options.cpp

@@ -131,11 +131,6 @@ void spvValidatorOptionsSetAllowOffsetTextureOperand(
   options->allow_offset_texture_operand = val;
 }
 
-void spvValidatorOptionsSetAllowVulkan32BitBitwise(
-    spv_validator_options options, bool val) {
-  options->allow_vulkan_32_bit_bitwise = val;
-}
-
 void spvValidatorOptionsSetFriendlyNames(spv_validator_options options,
                                          bool val) {
   options->use_friendly_names = val;

third_party/spirv-tools/source/spirv_validator_options.h

@@ -49,7 +49,6 @@ struct spv_validator_options_t {
         skip_block_layout(false),
         allow_localsizeid(false),
         allow_offset_texture_operand(false),
-        allow_vulkan_32_bit_bitwise(false),
         before_hlsl_legalization(false),
         use_friendly_names(true) {}
 
@@ -63,7 +62,6 @@ struct spv_validator_options_t {
   bool skip_block_layout;
   bool allow_localsizeid;
   bool allow_offset_texture_operand;
-  bool allow_vulkan_32_bit_bitwise;
   bool before_hlsl_legalization;
   bool use_friendly_names;
 };

third_party/spirv-tools/source/text.cpp

@@ -515,124 +515,6 @@ spv_result_t encodeInstructionStartingWithImmediate(
   return SPV_SUCCESS;
 }
 
-/// @brief Translate an instruction started by OpUnknown and the following
-/// operands to binary form
-///
-/// @param[in] grammar the grammar to use for compilation
-/// @param[in, out] context the dynamic compilation info
-/// @param[out] pInst returned binary Opcode
-///
-/// @return result code
-spv_result_t encodeInstructionStartingWithOpUnknown(
-    const spvtools::AssemblyGrammar& grammar,
-    spvtools::AssemblyContext* context, spv_instruction_t* pInst) {
-  spv_position_t nextPosition = {};
-
-  uint16_t opcode;
-  uint16_t wordCount;
-
-  // The '(' character.
-  if (context->advance())
-    return context->diagnostic() << "Expected '(', found end of stream.";
-  if ('(' != context->peek()) {
-    return context->diagnostic() << "'(' expected after OpUnknown but found '"
-                                 << context->peek() << "'.";
-  }
-  context->seekForward(1);
-
-  // The opcode enumerant.
-  if (context->advance())
-    return context->diagnostic()
-           << "Expected opcode enumerant, found end of stream.";
-  std::string opcodeString;
-  spv_result_t error = context->getWord(&opcodeString, &nextPosition);
-  if (error) return context->diagnostic(error) << "Internal Error";
-
-  if (!spvtools::utils::ParseNumber(opcodeString.c_str(), &opcode)) {
-    return context->diagnostic()
-           << "Invalid opcode enumerant: \"" << opcodeString << "\".";
-  }
-
-  context->setPosition(nextPosition);
-
-  // The ',' character.
-  if (context->advance())
-    return context->diagnostic() << "Expected ',', found end of stream.";
-  if (',' != context->peek()) {
-    return context->diagnostic()
-           << "',' expected after opcode enumerant but found '"
-           << context->peek() << "'.";
-  }
-  context->seekForward(1);
-
-  // The number of words.
-  if (context->advance())
-    return context->diagnostic()
-           << "Expected number of words, found end of stream.";
-  std::string wordCountString;
-  error = context->getWord(&wordCountString, &nextPosition);
-  if (error) return context->diagnostic(error) << "Internal Error";
-
-  if (!spvtools::utils::ParseNumber(wordCountString.c_str(), &wordCount)) {
-    return context->diagnostic()
-           << "Invalid number of words: \"" << wordCountString << "\".";
-  }
-
-  if (wordCount == 0) {
-    return context->diagnostic() << "Number of words (which includes the "
-                                    "opcode) must be greater than zero.";
-  }
-
-  context->setPosition(nextPosition);
-
-  // The ')' character.
-  if (context->advance())
-    return context->diagnostic() << "Expected ')', found end of stream.";
-  if (')' != context->peek()) {
-    return context->diagnostic()
-           << "')' expected after number of words but found '"
-           << context->peek() << "'.";
-  }
-  context->seekForward(1);
-
-  pInst->opcode = static_cast<spv::Op>(opcode);
-  context->binaryEncodeU32(spvOpcodeMake(wordCount, pInst->opcode), pInst);
-
-  wordCount--;  // Subtract the opcode from the number of words left to read.
-
-  while (wordCount-- > 0) {
-    if (context->advance() == SPV_END_OF_STREAM) {
-      return context->diagnostic() << "Expected " << wordCount + 1
-                                   << " more operands, found end of stream.";
-    }
-    if (context->isStartOfNewInst()) {
-      std::string invalid;
-      context->getWord(&invalid, &nextPosition);
-      return context->diagnostic()
-             << "Unexpected start of new instruction: \"" << invalid
-             << "\". Expected " << wordCount + 1 << " more operands";
-    }
-
-    std::string operandValue;
-    if ((error = context->getWord(&operandValue, &nextPosition)))
-      return context->diagnostic(error) << "Internal Error";
-
-    if (operandValue == "=")
-      return context->diagnostic() << "OpUnknown not allowed before =.";
-
-    // Needed to pass to spvTextEncodeOpcode(), but it shouldn't ever be
-    // expanded.
-    spv_operand_pattern_t dummyExpectedOperands;
-    error = spvTextEncodeOperand(
-        grammar, context, SPV_OPERAND_TYPE_OPTIONAL_CIV, operandValue.c_str(),
-        pInst, &dummyExpectedOperands);
-    if (error) return error;
-    context->setPosition(nextPosition);
-  }
-
-  return SPV_SUCCESS;
-}
-
 /// @brief Translate single Opcode and operands to binary form
 ///
 /// @param[in] grammar the grammar to use for compilation
@@ -692,16 +574,6 @@ spv_result_t spvTextEncodeOpcode(const spvtools::AssemblyGrammar& grammar,
     }
   }
 
-  if (opcodeName == "OpUnknown") {
-    if (!result_id.empty()) {
-      return context->diagnostic()
-             << "OpUnknown not allowed in assignment. Use an explicit result "
-                "id operand instead.";
-    }
-    context->setPosition(nextPosition);
-    return encodeInstructionStartingWithOpUnknown(grammar, context, pInst);
-  }
-
   // NOTE: The table contains Opcode names without the "Op" prefix.
   const char* pInstName = opcodeName.data() + 2;
 

third_party/spirv-tools/source/text_handler.cpp

@@ -118,9 +118,6 @@ spv_result_t getWord(spv_text text, spv_position position, std::string* word) {
           break;
         case ' ':
         case ';':
-        case ',':
-        case '(':
-        case ')':
         case '\t':
         case '\n':
         case '\r':

third_party/spirv-tools/source/util/small_vector.h

@@ -43,7 +43,6 @@ namespace utils {
 template <class T, size_t small_size>
 class SmallVector {
  public:
-  using value_type = T;
   using iterator = T*;
   using const_iterator = const T*;
 

third_party/spirv-tools/source/util/string_utils.h

@@ -17,12 +17,13 @@
 
 #include <assert.h>
 
-#include <cstdint>
 #include <cstring>
 #include <sstream>
 #include <string>
 #include <vector>
 
+#include "source/util/string_utils.h"
+
 namespace spvtools {
 namespace utils {
 
@@ -47,9 +48,8 @@ std::pair<std::string, std::string> SplitFlagArgs(const std::string& flag);
 
 // Encodes a string as a sequence of words, using the SPIR-V encoding, appending
 // to an existing vector.
-template <class VectorType = std::vector<uint32_t>>
-inline void AppendToVector(const std::string& input, VectorType* result) {
-  static_assert(std::is_same<uint32_t, typename VectorType::value_type>::value);
+inline void AppendToVector(const std::string& input,
+                           std::vector<uint32_t>* result) {
   uint32_t word = 0;
   size_t num_bytes = input.size();
   // SPIR-V strings are null-terminated.  The byte_index == num_bytes
@@ -70,10 +70,8 @@ inline void AppendToVector(const std::string& input, VectorType* result) {
 }
 
 // Encodes a string as a sequence of words, using the SPIR-V encoding.
-template <class VectorType = std::vector<uint32_t>>
-inline VectorType MakeVector(const std::string& input) {
-  static_assert(std::is_same<uint32_t, typename VectorType::value_type>::value);
-  VectorType result;
+inline std::vector<uint32_t> MakeVector(const std::string& input) {
+  std::vector<uint32_t> result;
   AppendToVector(input, &result);
   return result;
 }

third_party/spirv-tools/source/val/validate_bitwise.cpp

@@ -30,14 +30,14 @@ spv_result_t ValidateBaseType(ValidationState_t& _, const Instruction* inst,
 
   if (!_.IsIntScalarType(base_type) && !_.IsIntVectorType(base_type)) {
     return _.diag(SPV_ERROR_INVALID_DATA, inst)
+           << _.VkErrorID(4781)
            << "Expected int scalar or vector type for Base operand: "
            << spvOpcodeString(opcode);
   }
 
   // Vulkan has a restriction to 32 bit for base
   if (spvIsVulkanEnv(_.context()->target_env)) {
-    if (_.GetBitWidth(base_type) != 32 &&
-        !_.options()->allow_vulkan_32_bit_bitwise) {
+    if (_.GetBitWidth(base_type) != 32) {
       return _.diag(SPV_ERROR_INVALID_DATA, inst)
              << _.VkErrorID(4781)
              << "Expected 32-bit int type for Base operand: "

third_party/spirv-tools/source/val/validate_decorations.cpp

@@ -509,15 +509,6 @@ spv_result_t checkLayout(uint32_t struct_id, const char* storage_class_str,
     // Check offset.
     if (offset == 0xffffffff)
       return fail(memberIdx) << "is missing an Offset decoration";
-
-    if (opcode == spv::Op::OpTypeRuntimeArray &&
-        ordered_member_idx != member_offsets.size() - 1) {
-      return vstate.diag(SPV_ERROR_INVALID_ID, vstate.FindDef(struct_id))
-             << vstate.VkErrorID(4680) << "Structure id " << struct_id
-             << " has a runtime array at offset " << offset
-             << ", but other members at larger offsets";
-    }
-
     if (!scalar_block_layout && relaxed_block_layout &&
         opcode == spv::Op::OpTypeVector) {
       // In relaxed block layout, the vector offset must be aligned to the
@@ -1925,7 +1916,7 @@ spv_result_t CheckComponentDecoration(ValidationState_t& vstate,
     if (!vstate.IsIntScalarOrVectorType(type_id) &&
         !vstate.IsFloatScalarOrVectorType(type_id)) {
       return vstate.diag(SPV_ERROR_INVALID_ID, &inst)
-             << vstate.VkErrorID(10583)
+             << vstate.VkErrorID(4924)
              << "Component decoration specified for type "
              << vstate.getIdName(type_id) << " that is not a scalar or vector";
     }
@@ -2092,204 +2083,6 @@ spv_result_t CheckDecorationsFromDecoration(ValidationState_t& vstate) {
   return SPV_SUCCESS;
 }
 
-bool AllowsLayout(ValidationState_t& vstate, const spv::StorageClass sc) {
-  switch (sc) {
-    case spv::StorageClass::StorageBuffer:
-    case spv::StorageClass::Uniform:
-    case spv::StorageClass::PhysicalStorageBuffer:
-    case spv::StorageClass::PushConstant:
-      // Always explicitly laid out.
-      return true;
-    case spv::StorageClass::UniformConstant:
-      return false;
-    case spv::StorageClass::Workgroup:
-      return vstate.HasCapability(
-          spv::Capability::WorkgroupMemoryExplicitLayoutKHR);
-    case spv::StorageClass::Function:
-    case spv::StorageClass::Private:
-      return vstate.version() <= SPV_SPIRV_VERSION_WORD(1, 4);
-    case spv::StorageClass::Input:
-    case spv::StorageClass::Output:
-      // Block is used generally and mesh shaders use Offset.
-      return true;
-    default:
-      // TODO: Some storage classes in ray tracing use explicit layout
-      // decorations, but it is not well documented which. For now treat other
-      // storage classes as allowed to be laid out. See Vulkan internal issue
-      // 4192.
-      return true;
-  }
-}
-
-bool UsesExplicitLayout(ValidationState_t& vstate, uint32_t type_id,
-                        std::unordered_map<uint32_t, bool>& cache) {
-  if (type_id == 0) {
-    return false;
-  }
-
-  if (cache.count(type_id)) {
-    return cache[type_id];
-  }
-
-  bool res = false;
-  const auto type_inst = vstate.FindDef(type_id);
-  if (type_inst->opcode() == spv::Op::OpTypeStruct ||
-      type_inst->opcode() == spv::Op::OpTypeArray ||
-      type_inst->opcode() == spv::Op::OpTypeRuntimeArray ||
-      type_inst->opcode() == spv::Op::OpTypePointer ||
-      type_inst->opcode() == spv::Op::OpTypeUntypedPointerKHR) {
-    const auto& id_decs = vstate.id_decorations();
-    const auto iter = id_decs.find(type_id);
-    if (iter != id_decs.end()) {
-      bool allowLayoutDecorations = false;
-      if (type_inst->opcode() == spv::Op::OpTypePointer) {
-        const auto sc = type_inst->GetOperandAs<spv::StorageClass>(1);
-        allowLayoutDecorations = AllowsLayout(vstate, sc);
-      }
-      if (!allowLayoutDecorations) {
-        res = std::any_of(
-            iter->second.begin(), iter->second.end(), [](const Decoration& d) {
-              return d.dec_type() == spv::Decoration::Block ||
-                     d.dec_type() == spv::Decoration::BufferBlock ||
-                     d.dec_type() == spv::Decoration::Offset ||
-                     d.dec_type() == spv::Decoration::ArrayStride ||
-                     d.dec_type() == spv::Decoration::MatrixStride;
-            });
-      }
-    }
-
-    if (!res) {
-      switch (type_inst->opcode()) {
-        case spv::Op::OpTypeStruct:
-          for (uint32_t i = 1; !res && i < type_inst->operands().size(); i++) {
-            res = UsesExplicitLayout(
-                vstate, type_inst->GetOperandAs<uint32_t>(i), cache);
-          }
-          break;
-        case spv::Op::OpTypeArray:
-        case spv::Op::OpTypeRuntimeArray:
-          res = UsesExplicitLayout(vstate, type_inst->GetOperandAs<uint32_t>(1),
-                                   cache);
-          break;
-        case spv::Op::OpTypePointer: {
-          const auto sc = type_inst->GetOperandAs<spv::StorageClass>(1);
-          if (!AllowsLayout(vstate, sc)) {
-            res = UsesExplicitLayout(
-                vstate, type_inst->GetOperandAs<uint32_t>(2), cache);
-          }
-        }
-        default:
-          break;
-      }
-    }
-  }
-
-  cache[type_id] = res;
-  return res;
-}
-
-spv_result_t CheckInvalidVulkanExplicitLayout(ValidationState_t& vstate) {
-  if (!spvIsVulkanEnv(vstate.context()->target_env)) {
-    return SPV_SUCCESS;
-  }
-
-  std::unordered_map<uint32_t, bool> cache;
-  for (const auto& inst : vstate.ordered_instructions()) {
-    const auto type_id = inst.type_id();
-    const auto type_inst = vstate.FindDef(type_id);
-    uint32_t fail_id = 0;
-    // Variables are the main place to check for improper decorations, but some
-    // untyped pointer instructions must also be checked since those types may
-    // never be instantiated by a variable. Unlike verifying a valid layout,
-    // physical storage buffer does not need checked here since it is always
-    // explicitly laid out.
-    switch (inst.opcode()) {
-      case spv::Op::OpVariable:
-      case spv::Op::OpUntypedVariableKHR: {
-        const auto sc = inst.GetOperandAs<spv::StorageClass>(2);
-        auto check_id = type_id;
-        if (inst.opcode() == spv::Op::OpUntypedVariableKHR) {
-          if (inst.operands().size() > 3) {
-            check_id = inst.GetOperandAs<uint32_t>(3);
-          }
-        }
-        if (!AllowsLayout(vstate, sc) &&
-            UsesExplicitLayout(vstate, check_id, cache)) {
-          fail_id = check_id;
-        }
-        break;
-      }
-      case spv::Op::OpUntypedAccessChainKHR:
-      case spv::Op::OpUntypedInBoundsAccessChainKHR:
-      case spv::Op::OpUntypedPtrAccessChainKHR:
-      case spv::Op::OpUntypedInBoundsPtrAccessChainKHR: {
-        // Check both the base type and return type. The return type may have an
-        // invalid array stride.
-        const auto sc = type_inst->GetOperandAs<spv::StorageClass>(1);
-        const auto base_type_id = inst.GetOperandAs<uint32_t>(2);
-        if (!AllowsLayout(vstate, sc)) {
-          if (UsesExplicitLayout(vstate, base_type_id, cache)) {
-            fail_id = base_type_id;
-          } else if (UsesExplicitLayout(vstate, type_id, cache)) {
-            fail_id = type_id;
-          }
-        }
-        break;
-      }
-      case spv::Op::OpUntypedArrayLengthKHR: {
-        // Check the data type.
-        const auto ptr_ty_id =
-            vstate.FindDef(inst.GetOperandAs<uint32_t>(3))->type_id();
-        const auto ptr_ty = vstate.FindDef(ptr_ty_id);
-        const auto sc = ptr_ty->GetOperandAs<spv::StorageClass>(1);
-        const auto base_type_id = inst.GetOperandAs<uint32_t>(2);
-        if (!AllowsLayout(vstate, sc) &&
-            UsesExplicitLayout(vstate, base_type_id, cache)) {
-          fail_id = base_type_id;
-        }
-        break;
-      }
-      case spv::Op::OpLoad: {
-        const auto ptr_id = inst.GetOperandAs<uint32_t>(2);
-        const auto ptr_type = vstate.FindDef(vstate.FindDef(ptr_id)->type_id());
-        if (ptr_type->opcode() == spv::Op::OpTypeUntypedPointerKHR) {
-          // For untyped pointers check the return type for an invalid layout.
-          const auto sc = ptr_type->GetOperandAs<spv::StorageClass>(1);
-          if (!AllowsLayout(vstate, sc) &&
-              UsesExplicitLayout(vstate, type_id, cache)) {
-            fail_id = type_id;
-          }
-        }
-        break;
-      }
-      case spv::Op::OpStore: {
-        const auto ptr_id = inst.GetOperandAs<uint32_t>(1);
-        const auto ptr_type = vstate.FindDef(vstate.FindDef(ptr_id)->type_id());
-        if (ptr_type->opcode() == spv::Op::OpTypeUntypedPointerKHR) {
-          // For untyped pointers, check the type of the data operand for an
-          // invalid layout.
-          const auto sc = ptr_type->GetOperandAs<spv::StorageClass>(1);
-          const auto data_type_id = vstate.GetOperandTypeId(&inst, 2);
-          if (!AllowsLayout(vstate, sc) &&
-              UsesExplicitLayout(vstate, data_type_id, cache)) {
-            fail_id = inst.GetOperandAs<uint32_t>(2);
-          }
-        }
-        break;
-      }
-      default:
-        break;
-    }
-    if (fail_id != 0) {
-      return vstate.diag(SPV_ERROR_INVALID_ID, &inst)
-             << "Invalid explicit layout decorations on type for operand "
-             << vstate.getIdName(fail_id);
-    }
-  }
-
-  return SPV_SUCCESS;
-}
-
 }  // namespace
 
 spv_result_t ValidateDecorations(ValidationState_t& vstate) {
@@ -2301,7 +2094,6 @@ spv_result_t ValidateDecorations(ValidationState_t& vstate) {
   if (auto error = CheckVulkanMemoryModelDeprecatedDecorations(vstate))
     return error;
   if (auto error = CheckDecorationsFromDecoration(vstate)) return error;
-  if (auto error = CheckInvalidVulkanExplicitLayout(vstate)) return error;
   return SPV_SUCCESS;
 }
 

third_party/spirv-tools/source/val/validate_function.cpp

@@ -258,8 +258,7 @@ spv_result_t ValidateFunctionCall(ValidationState_t& _,
               _.HasCapability(spv::Capability::VariablePointers) &&
               sc == spv::StorageClass::Workgroup;
           const bool uc_ptr = sc == spv::StorageClass::UniformConstant;
-          if (!_.options()->before_hlsl_legalization && !ssbo_vptr &&
-              !wg_vptr && !uc_ptr) {
+          if (!ssbo_vptr && !wg_vptr && !uc_ptr) {
             return _.diag(SPV_ERROR_INVALID_ID, inst)
                    << "Pointer operand " << _.getIdName(argument_id)
                    << " must be a memory object declaration";

third_party/spirv-tools/source/val/validate_interfaces.cpp

@@ -48,29 +48,6 @@ bool is_interface_variable(const Instruction* inst, bool is_spv_1_4) {
   }
 }
 
-// Special validation for varibles that are between shader stages
-spv_result_t ValidateInputOutputInterfaceVariables(ValidationState_t& _,
-                                                   const Instruction* var) {
-  auto var_pointer = _.FindDef(var->GetOperandAs<uint32_t>(0));
-  uint32_t pointer_id = var_pointer->GetOperandAs<uint32_t>(2);
-
-  const auto isPhysicalStorageBuffer = [](const Instruction* insn) {
-    return insn->opcode() == spv::Op::OpTypePointer &&
-           insn->GetOperandAs<spv::StorageClass>(1) ==
-               spv::StorageClass::PhysicalStorageBuffer;
-  };
-
-  if (_.ContainsType(pointer_id, isPhysicalStorageBuffer)) {
-    return _.diag(SPV_ERROR_INVALID_ID, var)
-           << _.VkErrorID(9557) << "Input/Output interface variable id <"
-           << var->id()
-           << "> contains a PhysicalStorageBuffer pointer, which is not "
-              "allowed. If you want to interface shader stages with a "
-              "PhysicalStorageBuffer, cast to a uint64 or uvec2 instead.";
-  }
-  return SPV_SUCCESS;
-}
-
 // Checks that \c var is listed as an interface in all the entry points that use
 // it.
 spv_result_t check_interface_variable(ValidationState_t& _,
@@ -130,12 +107,6 @@ spv_result_t check_interface_variable(ValidationState_t& _,
     }
   }
 
-  if (var->GetOperandAs<spv::StorageClass>(2) == spv::StorageClass::Input ||
-      var->GetOperandAs<spv::StorageClass>(2) == spv::StorageClass::Output) {
-    if (auto error = ValidateInputOutputInterfaceVariables(_, var))
-      return error;
-  }
-
   return SPV_SUCCESS;
 }
 
@@ -164,20 +135,17 @@ spv_result_t NumConsumedLocations(ValidationState_t& _, const Instruction* type,
       }
       break;
     case spv::Op::OpTypeMatrix:
-      // Matrices consume locations equivalent to arrays.
-      if (auto error = NumConsumedLocations(
-              _, _.FindDef(type->GetOperandAs<uint32_t>(1)), num_locations)) {
-        return error;
-      }
+      // Matrices consume locations equal to the underlying vector type for
+      // each column.
+      NumConsumedLocations(_, _.FindDef(type->GetOperandAs<uint32_t>(1)),
+                           num_locations);
       *num_locations *= type->GetOperandAs<uint32_t>(2);
       break;
     case spv::Op::OpTypeArray: {
       // Arrays consume locations equal to the underlying type times the number
       // of elements in the vector.
-      if (auto error = NumConsumedLocations(
-              _, _.FindDef(type->GetOperandAs<uint32_t>(1)), num_locations)) {
-        return error;
-      }
+      NumConsumedLocations(_, _.FindDef(type->GetOperandAs<uint32_t>(1)),
+                           num_locations);
       bool is_int = false;
       bool is_const = false;
       uint32_t value = 0;
@@ -247,31 +215,10 @@ uint32_t NumConsumedComponents(ValidationState_t& _, const Instruction* type) {
           NumConsumedComponents(_, _.FindDef(type->GetOperandAs<uint32_t>(1)));
       num_components *= type->GetOperandAs<uint32_t>(2);
       break;
-    case spv::Op::OpTypeMatrix:
-      // Matrices consume all components of the location.
-      // Round up to next multiple of 4.
-      num_components =
-          NumConsumedComponents(_, _.FindDef(type->GetOperandAs<uint32_t>(1)));
-      num_components *= type->GetOperandAs<uint32_t>(2);
-      num_components = ((num_components + 3) / 4) * 4;
-      break;
-    case spv::Op::OpTypeArray: {
-      // Arrays consume all components of the location.
-      // Round up to next multiple of 4.
-      num_components =
-          NumConsumedComponents(_, _.FindDef(type->GetOperandAs<uint32_t>(1)));
-
-      bool is_int = false;
-      bool is_const = false;
-      uint32_t value = 0;
-      // Attempt to evaluate the number of array elements.
-      std::tie(is_int, is_const, value) =
-          _.EvalInt32IfConst(type->GetOperandAs<uint32_t>(2));
-      if (is_int && is_const) num_components *= value;
-
-      num_components = ((num_components + 3) / 4) * 4;
-      return num_components;
-    }
+    case spv::Op::OpTypeArray:
+      // Skip the array.
+      return NumConsumedComponents(_,
+                                   _.FindDef(type->GetOperandAs<uint32_t>(1)));
     case spv::Op::OpTypePointer:
       if (_.addressing_model() ==
               spv::AddressingModel::PhysicalStorageBuffer64 &&
@@ -354,10 +301,9 @@ spv_result_t GetLocationsForVariable(
     }
   }
 
-  // Vulkan 15.1.3 (Interface Matching): Tessellation control and mesh
-  // per-vertex outputs and tessellation control, evaluation and geometry
-  // per-vertex inputs have a layer of arraying that is not included in
-  // interface matching.
+  // Vulkan 14.1.3: Tessellation control and mesh per-vertex outputs and
+  // tessellation control, evaluation and geometry per-vertex inputs have a
+  // layer of arraying that is not included in interface matching.
   bool is_arrayed = false;
   switch (entry_point->GetOperandAs<spv::ExecutionModel>(0)) {
     case spv::ExecutionModel::TessellationControl:
@@ -411,33 +357,51 @@ spv_result_t GetLocationsForVariable(
 
   const std::string storage_class = is_output ? "output" : "input";
   if (has_location) {
+    auto sub_type = type;
+    bool is_int = false;
+    bool is_const = false;
+    uint32_t array_size = 1;
+    // If the variable is still arrayed, mark the locations/components per
+    // index.
+    if (type->opcode() == spv::Op::OpTypeArray) {
+      // Determine the array size if possible and get the element type.
+      std::tie(is_int, is_const, array_size) =
+          _.EvalInt32IfConst(type->GetOperandAs<uint32_t>(2));
+      if (!is_int || !is_const) array_size = 1;
+      auto sub_type_id = type->GetOperandAs<uint32_t>(1);
+      sub_type = _.FindDef(sub_type_id);
+    }
+
     uint32_t num_locations = 0;
-    if (auto error = NumConsumedLocations(_, type, &num_locations))
+    if (auto error = NumConsumedLocations(_, sub_type, &num_locations))
       return error;
-    uint32_t num_components = NumConsumedComponents(_, type);
+    uint32_t num_components = NumConsumedComponents(_, sub_type);
 
-    uint32_t start = location * 4;
-    uint32_t end = (location + num_locations) * 4;
-    if (num_components % 4 != 0) {
-      start += component;
-      end = start + num_components;
-    }
+    for (uint32_t array_idx = 0; array_idx < array_size; ++array_idx) {
+      uint32_t array_location = location + (num_locations * array_idx);
+      uint32_t start = array_location * 4;
+      if (kMaxLocations <= start) {
+        // Too many locations, give up.
+        break;
+      }
 
-    if (kMaxLocations <= start) {
-      // Too many locations, give up.
-      return SPV_SUCCESS;
-    }
+      uint32_t end = (array_location + num_locations) * 4;
+      if (num_components != 0) {
+        start += component;
+        end = array_location * 4 + component + num_components;
+      }
 
-    auto locs = locations;
-    if (has_index && index == 1) locs = output_index1_locations;
+      auto locs = locations;
+      if (has_index && index == 1) locs = output_index1_locations;
 
-    for (uint32_t i = start; i < end; ++i) {
-      if (!locs->insert(i).second) {
-        return _.diag(SPV_ERROR_INVALID_DATA, entry_point)
-               << (is_output ? _.VkErrorID(8722) : _.VkErrorID(8721))
-               << "Entry-point has conflicting " << storage_class
-               << " location assignment at location " << i / 4 << ", component "
-               << i % 4;
+      for (uint32_t i = start; i < end; ++i) {
+        if (!locs->insert(i).second) {
+          return _.diag(SPV_ERROR_INVALID_DATA, entry_point)
+                 << (is_output ? _.VkErrorID(8722) : _.VkErrorID(8721))
+                 << "Entry-point has conflicting " << storage_class
+                 << " location assignment at location " << i / 4
+                 << ", component " << i % 4;
+        }
       }
     }
   } else {
@@ -496,19 +460,38 @@ spv_result_t GetLocationsForVariable(
         continue;
       }
 
-      uint32_t end = (location + num_locations) * 4;
-      if (num_components % 4 != 0) {
-        start += component;
-        end = location * 4 + component + num_components;
-      }
-
-      for (uint32_t l = start; l < end; ++l) {
-        if (!locations->insert(l).second) {
-          return _.diag(SPV_ERROR_INVALID_DATA, entry_point)
-                 << (is_output ? _.VkErrorID(8722) : _.VkErrorID(8721))
-                 << "Entry-point has conflicting " << storage_class
-                 << " location assignment at location " << l / 4
-                 << ", component " << l % 4;
+      if (member->opcode() == spv::Op::OpTypeArray && num_components >= 1 &&
+          num_components < 4) {
+        // When an array has an element that takes less than a location in
+        // size, calculate the used locations in a strided manner.
+        for (uint32_t l = location; l < num_locations + location; ++l) {
+          for (uint32_t c = component; c < component + num_components; ++c) {
+            uint32_t check = 4 * l + c;
+            if (!locations->insert(check).second) {
+              return _.diag(SPV_ERROR_INVALID_DATA, entry_point)
+                     << (is_output ? _.VkErrorID(8722) : _.VkErrorID(8721))
+                     << "Entry-point has conflicting " << storage_class
+                     << " location assignment at location " << l
+                     << ", component " << c;
+            }
+          }
+        }
+      } else {
+        // TODO: There is a hole here is the member is an array of 3- or
+        // 4-element vectors of 64-bit types.
+        uint32_t end = (location + num_locations) * 4;
+        if (num_components != 0) {
+          start += component;
+          end = location * 4 + component + num_components;
+        }
+        for (uint32_t l = start; l < end; ++l) {
+          if (!locations->insert(l).second) {
+            return _.diag(SPV_ERROR_INVALID_DATA, entry_point)
+                   << (is_output ? _.VkErrorID(8722) : _.VkErrorID(8721))
+                   << "Entry-point has conflicting " << storage_class
+                   << " location assignment at location " << l / 4
+                   << ", component " << l % 4;
+          }
         }
       }
     }

third_party/spirv-tools/source/val/validate_memory.cpp

@@ -380,16 +380,6 @@ spv_result_t CheckMemoryAccess(ValidationState_t& _, const Instruction* inst,
              << _.VkErrorID(4708)
              << "Memory accesses with PhysicalStorageBuffer must use Aligned.";
     }
-  } else {
-    // even if there are other masks, the Aligned operand will be next
-    const uint32_t aligned_value = inst->GetOperandAs<uint32_t>(index + 1);
-    const bool is_power_of_two =
-        aligned_value && !(aligned_value & (aligned_value - 1));
-    if (!is_power_of_two) {
-      return _.diag(SPV_ERROR_INVALID_ID, inst)
-             << "Memory accesses Aligned operand value " << aligned_value
-             << " is not a power of two.";
-    }
   }
 
   return SPV_SUCCESS;
@@ -2791,42 +2781,17 @@ spv_result_t ValidatePtrComparison(ValidationState_t& _,
 
   const auto op1 = _.FindDef(inst->GetOperandAs<uint32_t>(2u));
   const auto op2 = _.FindDef(inst->GetOperandAs<uint32_t>(3u));
+  if (!op1 || !op2 || op1->type_id() != op2->type_id()) {
+    return _.diag(SPV_ERROR_INVALID_ID, inst)
+           << "The types of Operand 1 and Operand 2 must match";
+  }
   const auto op1_type = _.FindDef(op1->type_id());
-  const auto op2_type = _.FindDef(op2->type_id());
   if (!op1_type || (op1_type->opcode() != spv::Op::OpTypePointer &&
                     op1_type->opcode() != spv::Op::OpTypeUntypedPointerKHR)) {
     return _.diag(SPV_ERROR_INVALID_ID, inst)
            << "Operand type must be a pointer";
   }
 
-  if (!op2_type || (op2_type->opcode() != spv::Op::OpTypePointer &&
-                    op2_type->opcode() != spv::Op::OpTypeUntypedPointerKHR)) {
-    return _.diag(SPV_ERROR_INVALID_ID, inst)
-           << "Operand type must be a pointer";
-  }
-
-  if (inst->opcode() == spv::Op::OpPtrDiff) {
-    if (op1->type_id() != op2->type_id()) {
-      return _.diag(SPV_ERROR_INVALID_ID, inst)
-             << "The types of Operand 1 and Operand 2 must match";
-    }
-  } else {
-    const auto either_untyped =
-        op1_type->opcode() == spv::Op::OpTypeUntypedPointerKHR ||
-        op2_type->opcode() == spv::Op::OpTypeUntypedPointerKHR;
-    if (either_untyped) {
-      const auto sc1 = op1_type->GetOperandAs<spv::StorageClass>(1);
-      const auto sc2 = op2_type->GetOperandAs<spv::StorageClass>(1);
-      if (sc1 != sc2) {
-        return _.diag(SPV_ERROR_INVALID_ID, inst)
-               << "Pointer storage classes must match";
-      }
-    } else if (op1->type_id() != op2->type_id()) {
-      return _.diag(SPV_ERROR_INVALID_ID, inst)
-             << "The types of Operand 1 and Operand 2 must match";
-    }
-  }
-
   spv::StorageClass sc = op1_type->GetOperandAs<spv::StorageClass>(1u);
   if (_.addressing_model() == spv::AddressingModel::Logical) {
     if (sc != spv::StorageClass::Workgroup &&

third_party/spirv-tools/source/val/validate_memory_semantics.cpp

@@ -66,7 +66,8 @@ spv_result_t ValidateMemorySemantics(ValidationState_t& _,
     return _.diag(SPV_ERROR_INVALID_DATA, inst)
            << spvOpcodeString(opcode)
            << ": Memory Semantics can have at most one of the following "
-              "bits set: Acquire, Release, AcquireRelease or "
+              "bits "
+              "set: Acquire, Release, AcquireRelease or "
               "SequentiallyConsistent";
   }
 
@@ -175,8 +176,10 @@ spv_result_t ValidateMemorySemantics(ValidationState_t& _,
       return _.diag(SPV_ERROR_INVALID_DATA, inst)
              << _.VkErrorID(4732) << spvOpcodeString(opcode)
              << ": Vulkan specification requires Memory Semantics to have "
-                "one of the following bits set: Acquire, Release, "
-                "AcquireRelease or SequentiallyConsistent";
+                "one "
+                "of the following bits set: Acquire, Release, "
+                "AcquireRelease "
+                "or SequentiallyConsistent";
     } else if (opcode != spv::Op::OpMemoryBarrier &&
                num_memory_order_set_bits) {
       // should leave only atomics and control barriers for Vulkan env
@@ -200,20 +203,11 @@ spv_result_t ValidateMemorySemantics(ValidationState_t& _,
                 "storage class";
     }
 
-    if (opcode == spv::Op::OpControlBarrier && value) {
-      if (!num_memory_order_set_bits) {
-        return _.diag(SPV_ERROR_INVALID_DATA, inst)
-               << _.VkErrorID(10609) << spvOpcodeString(opcode)
-               << ": Vulkan specification requires non-zero Memory Semantics "
-                  "to have one of the following bits set: Acquire, Release, "
-                  "AcquireRelease or SequentiallyConsistent";
-      }
-      if (!includes_storage_class) {
-        return _.diag(SPV_ERROR_INVALID_DATA, inst)
-               << _.VkErrorID(4650) << spvOpcodeString(opcode)
-               << ": expected Memory Semantics to include a Vulkan-supported "
-                  "storage class if Memory Semantics is not None";
-      }
+    if (opcode == spv::Op::OpControlBarrier && value && !includes_storage_class) {
+      return _.diag(SPV_ERROR_INVALID_DATA, inst)
+             << _.VkErrorID(4650) << spvOpcodeString(opcode)
+             << ": expected Memory Semantics to include a Vulkan-supported "
+                "storage class if Memory Semantics is not None";
     }
   }